diff --git a/addon/globalPlugins/spellcheck/language_dictionary.py b/addon/globalPlugins/spellcheck/language_dictionary.py
index 5bec482..1d1753d 100644
--- a/addon/globalPlugins/spellcheck/language_dictionary.py
+++ b/addon/globalPlugins/spellcheck/language_dictionary.py
@@ -7,6 +7,7 @@
 import os
 import globalVars
 import languageHandler
+from concurrent.futures import ThreadPoolExecutor
 from io import BytesIO
 from functools import partial
 from logHandler import log
@@ -16,7 +17,6 @@
 with import_bundled_library():
     import enchant
     import httpx
-    from concurrent.futures import ThreadPoolExecutor
 
 
 # Constants
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/__init__.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/__init__.py
new file mode 100644
index 0000000..26135ad
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/__init__.py
@@ -0,0 +1,566 @@
+"""create and manipulate C data types in Python"""
+
+import os as _os, sys as _sys
+import types as _types
+
+__version__ = "1.1.0"
+
+from _ctypes import Union, Structure, Array
+from _ctypes import _Pointer
+from _ctypes import CFuncPtr as _CFuncPtr
+from _ctypes import __version__ as _ctypes_version
+from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
+from _ctypes import ArgumentError
+
+from struct import calcsize as _calcsize
+
+if __version__ != _ctypes_version:
+    raise Exception("Version number mismatch", __version__, _ctypes_version)
+
+if _os.name == "nt":
+    from _ctypes import FormatError
+
+DEFAULT_MODE = RTLD_LOCAL
+if _os.name == "posix" and _sys.platform == "darwin":
+    # On OS X 10.3, we use RTLD_GLOBAL as default mode
+    # because RTLD_LOCAL does not work at least on some
+    # libraries.  OS X 10.3 is Darwin 7, so we check for
+    # that.
+
+    if int(_os.uname().release.split('.')[0]) < 8:
+        DEFAULT_MODE = RTLD_GLOBAL
+
+from _ctypes import FUNCFLAG_CDECL as _FUNCFLAG_CDECL, \
+     FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI, \
+     FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO, \
+     FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR
+
+# WINOLEAPI -> HRESULT
+# WINOLEAPI_(type)
+#
+# STDMETHODCALLTYPE
+#
+# STDMETHOD(name)
+# STDMETHOD_(type, name)
+#
+# STDAPICALLTYPE
+
+def create_string_buffer(init, size=None):
+    """create_string_buffer(aBytes) -> character array
+    create_string_buffer(anInteger) -> character array
+    create_string_buffer(aBytes, anInteger) -> character array
+    """
+    if isinstance(init, bytes):
+        if size is None:
+            size = len(init)+1
+        _sys.audit("ctypes.create_string_buffer", init, size)
+        buftype = c_char * size
+        buf = buftype()
+        buf.value = init
+        return buf
+    elif isinstance(init, int):
+        _sys.audit("ctypes.create_string_buffer", None, init)
+        buftype = c_char * init
+        buf = buftype()
+        return buf
+    raise TypeError(init)
+
+# Alias to create_string_buffer() for backward compatibility
+c_buffer = create_string_buffer
+
+_c_functype_cache = {}
+def CFUNCTYPE(restype, *argtypes, **kw):
+    """CFUNCTYPE(restype, *argtypes,
+                 use_errno=False, use_last_error=False) -> function prototype.
+
+    restype: the result type
+    argtypes: a sequence specifying the argument types
+
+    The function prototype can be called in different ways to create a
+    callable object:
+
+    prototype(integer address) -> foreign function
+    prototype(callable) -> create and return a C callable function from callable
+    prototype(integer index, method name[, paramflags]) -> foreign function calling a COM method
+    prototype((ordinal number, dll object)[, paramflags]) -> foreign function exported by ordinal
+    prototype((function name, dll object)[, paramflags]) -> foreign function exported by name
+    """
+    flags = _FUNCFLAG_CDECL
+    if kw.pop("use_errno", False):
+        flags |= _FUNCFLAG_USE_ERRNO
+    if kw.pop("use_last_error", False):
+        flags |= _FUNCFLAG_USE_LASTERROR
+    if kw:
+        raise ValueError("unexpected keyword argument(s) %s" % kw.keys())
+
+    try:
+        return _c_functype_cache[(restype, argtypes, flags)]
+    except KeyError:
+        pass
+
+    class CFunctionType(_CFuncPtr):
+        _argtypes_ = argtypes
+        _restype_ = restype
+        _flags_ = flags
+    _c_functype_cache[(restype, argtypes, flags)] = CFunctionType
+    return CFunctionType
+
+if _os.name == "nt":
+    from _ctypes import LoadLibrary as _dlopen
+    from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
+
+    _win_functype_cache = {}
+    def WINFUNCTYPE(restype, *argtypes, **kw):
+        # docstring set later (very similar to CFUNCTYPE.__doc__)
+        flags = _FUNCFLAG_STDCALL
+        if kw.pop("use_errno", False):
+            flags |= _FUNCFLAG_USE_ERRNO
+        if kw.pop("use_last_error", False):
+            flags |= _FUNCFLAG_USE_LASTERROR
+        if kw:
+            raise ValueError("unexpected keyword argument(s) %s" % kw.keys())
+
+        try:
+            return _win_functype_cache[(restype, argtypes, flags)]
+        except KeyError:
+            pass
+
+        class WinFunctionType(_CFuncPtr):
+            _argtypes_ = argtypes
+            _restype_ = restype
+            _flags_ = flags
+        _win_functype_cache[(restype, argtypes, flags)] = WinFunctionType
+        return WinFunctionType
+    if WINFUNCTYPE.__doc__:
+        WINFUNCTYPE.__doc__ = CFUNCTYPE.__doc__.replace("CFUNCTYPE", "WINFUNCTYPE")
+
+elif _os.name == "posix":
+    from _ctypes import dlopen as _dlopen
+
+from _ctypes import sizeof, byref, addressof, alignment, resize
+from _ctypes import get_errno, set_errno
+from _ctypes import _SimpleCData
+
+def _check_size(typ, typecode=None):
+    # Check if sizeof(ctypes_type) against struct.calcsize.  This
+    # should protect somewhat against a misconfigured libffi.
+    from struct import calcsize
+    if typecode is None:
+        # Most _type_ codes are the same as used in struct
+        typecode = typ._type_
+    actual, required = sizeof(typ), calcsize(typecode)
+    if actual != required:
+        raise SystemError("sizeof(%s) wrong: %d instead of %d" % \
+                          (typ, actual, required))
+
+class py_object(_SimpleCData):
+    _type_ = "O"
+    def __repr__(self):
+        try:
+            return super().__repr__()
+        except ValueError:
+            return "%s(<NULL>)" % type(self).__name__
+_check_size(py_object, "P")
+
+class c_short(_SimpleCData):
+    _type_ = "h"
+_check_size(c_short)
+
+class c_ushort(_SimpleCData):
+    _type_ = "H"
+_check_size(c_ushort)
+
+class c_long(_SimpleCData):
+    _type_ = "l"
+_check_size(c_long)
+
+class c_ulong(_SimpleCData):
+    _type_ = "L"
+_check_size(c_ulong)
+
+if _calcsize("i") == _calcsize("l"):
+    # if int and long have the same size, make c_int an alias for c_long
+    c_int = c_long
+    c_uint = c_ulong
+else:
+    class c_int(_SimpleCData):
+        _type_ = "i"
+    _check_size(c_int)
+
+    class c_uint(_SimpleCData):
+        _type_ = "I"
+    _check_size(c_uint)
+
+class c_float(_SimpleCData):
+    _type_ = "f"
+_check_size(c_float)
+
+class c_double(_SimpleCData):
+    _type_ = "d"
+_check_size(c_double)
+
+class c_longdouble(_SimpleCData):
+    _type_ = "g"
+if sizeof(c_longdouble) == sizeof(c_double):
+    c_longdouble = c_double
+
+if _calcsize("l") == _calcsize("q"):
+    # if long and long long have the same size, make c_longlong an alias for c_long
+    c_longlong = c_long
+    c_ulonglong = c_ulong
+else:
+    class c_longlong(_SimpleCData):
+        _type_ = "q"
+    _check_size(c_longlong)
+
+    class c_ulonglong(_SimpleCData):
+        _type_ = "Q"
+    ##    def from_param(cls, val):
+    ##        return ('d', float(val), val)
+    ##    from_param = classmethod(from_param)
+    _check_size(c_ulonglong)
+
+class c_ubyte(_SimpleCData):
+    _type_ = "B"
+c_ubyte.__ctype_le__ = c_ubyte.__ctype_be__ = c_ubyte
+# backward compatibility:
+##c_uchar = c_ubyte
+_check_size(c_ubyte)
+
+class c_byte(_SimpleCData):
+    _type_ = "b"
+c_byte.__ctype_le__ = c_byte.__ctype_be__ = c_byte
+_check_size(c_byte)
+
+class c_char(_SimpleCData):
+    _type_ = "c"
+c_char.__ctype_le__ = c_char.__ctype_be__ = c_char
+_check_size(c_char)
+
+class c_char_p(_SimpleCData):
+    _type_ = "z"
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__.__name__, c_void_p.from_buffer(self).value)
+_check_size(c_char_p, "P")
+
+class c_void_p(_SimpleCData):
+    _type_ = "P"
+c_voidp = c_void_p # backwards compatibility (to a bug)
+_check_size(c_void_p)
+
+class c_bool(_SimpleCData):
+    _type_ = "?"
+
+from _ctypes import POINTER, pointer, _pointer_type_cache
+
+class c_wchar_p(_SimpleCData):
+    _type_ = "Z"
+    def __repr__(self):
+        return "%s(%s)" % (self.__class__.__name__, c_void_p.from_buffer(self).value)
+
+class c_wchar(_SimpleCData):
+    _type_ = "u"
+
+def _reset_cache():
+    _pointer_type_cache.clear()
+    _c_functype_cache.clear()
+    if _os.name == "nt":
+        _win_functype_cache.clear()
+    # _SimpleCData.c_wchar_p_from_param
+    POINTER(c_wchar).from_param = c_wchar_p.from_param
+    # _SimpleCData.c_char_p_from_param
+    POINTER(c_char).from_param = c_char_p.from_param
+    _pointer_type_cache[None] = c_void_p
+
+def create_unicode_buffer(init, size=None):
+    """create_unicode_buffer(aString) -> character array
+    create_unicode_buffer(anInteger) -> character array
+    create_unicode_buffer(aString, anInteger) -> character array
+    """
+    if isinstance(init, str):
+        if size is None:
+            if sizeof(c_wchar) == 2:
+                # UTF-16 requires a surrogate pair (2 wchar_t) for non-BMP
+                # characters (outside [U+0000; U+FFFF] range). +1 for trailing
+                # NUL character.
+                size = sum(2 if ord(c) > 0xFFFF else 1 for c in init) + 1
+            else:
+                # 32-bit wchar_t (1 wchar_t per Unicode character). +1 for
+                # trailing NUL character.
+                size = len(init) + 1
+        _sys.audit("ctypes.create_unicode_buffer", init, size)
+        buftype = c_wchar * size
+        buf = buftype()
+        buf.value = init
+        return buf
+    elif isinstance(init, int):
+        _sys.audit("ctypes.create_unicode_buffer", None, init)
+        buftype = c_wchar * init
+        buf = buftype()
+        return buf
+    raise TypeError(init)
+
+
+# XXX Deprecated
+def SetPointerType(pointer, cls):
+    if _pointer_type_cache.get(cls, None) is not None:
+        raise RuntimeError("This type already exists in the cache")
+    if id(pointer) not in _pointer_type_cache:
+        raise RuntimeError("What's this???")
+    pointer.set_type(cls)
+    _pointer_type_cache[cls] = pointer
+    del _pointer_type_cache[id(pointer)]
+
+# XXX Deprecated
+def ARRAY(typ, len):
+    return typ * len
+
+################################################################
+
+
+class CDLL(object):
+    """An instance of this class represents a loaded dll/shared
+    library, exporting functions using the standard C calling
+    convention (named 'cdecl' on Windows).
+
+    The exported functions can be accessed as attributes, or by
+    indexing with the function name.  Examples:
+
+    <obj>.qsort -> callable object
+    <obj>['qsort'] -> callable object
+
+    Calling the functions releases the Python GIL during the call and
+    reacquires it afterwards.
+    """
+    _func_flags_ = _FUNCFLAG_CDECL
+    _func_restype_ = c_int
+    # default values for repr
+    _name = '<uninitialized>'
+    _handle = 0
+    _FuncPtr = None
+
+    def __init__(self, name, mode=DEFAULT_MODE, handle=None,
+                 use_errno=False,
+                 use_last_error=False,
+                 winmode=None):
+        self._name = name
+        flags = self._func_flags_
+        if use_errno:
+            flags |= _FUNCFLAG_USE_ERRNO
+        if use_last_error:
+            flags |= _FUNCFLAG_USE_LASTERROR
+        if _sys.platform.startswith("aix"):
+            """When the name contains ".a(" and ends with ")",
+               e.g., "libFOO.a(libFOO.so)" - this is taken to be an
+               archive(member) syntax for dlopen(), and the mode is adjusted.
+               Otherwise, name is presented to dlopen() as a file argument.
+            """
+            if name and name.endswith(")") and ".a(" in name:
+                mode |= ( _os.RTLD_MEMBER | _os.RTLD_NOW )
+        if _os.name == "nt":
+            if winmode is not None:
+                mode = winmode
+            else:
+                import nt
+                mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
+                if '/' in name or '\\' in name:
+                    self._name = nt._getfullpathname(self._name)
+                    mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+
+        class _FuncPtr(_CFuncPtr):
+            _flags_ = flags
+            _restype_ = self._func_restype_
+        self._FuncPtr = _FuncPtr
+
+        if handle is None:
+            self._handle = _dlopen(self._name, mode)
+        else:
+            self._handle = handle
+
+    def __repr__(self):
+        return "<%s '%s', handle %x at %#x>" % \
+               (self.__class__.__name__, self._name,
+                (self._handle & (_sys.maxsize*2 + 1)),
+                id(self) & (_sys.maxsize*2 + 1))
+
+    def __getattr__(self, name):
+        if name.startswith('__') and name.endswith('__'):
+            raise AttributeError(name)
+        func = self.__getitem__(name)
+        setattr(self, name, func)
+        return func
+
+    def __getitem__(self, name_or_ordinal):
+        func = self._FuncPtr((name_or_ordinal, self))
+        if not isinstance(name_or_ordinal, int):
+            func.__name__ = name_or_ordinal
+        return func
+
+class PyDLL(CDLL):
+    """This class represents the Python library itself.  It allows
+    accessing Python API functions.  The GIL is not released, and
+    Python exceptions are handled correctly.
+    """
+    _func_flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
+
+if _os.name == "nt":
+
+    class WinDLL(CDLL):
+        """This class represents a dll exporting functions using the
+        Windows stdcall calling convention.
+        """
+        _func_flags_ = _FUNCFLAG_STDCALL
+
+    # XXX Hm, what about HRESULT as normal parameter?
+    # Mustn't it derive from c_long then?
+    from _ctypes import _check_HRESULT, _SimpleCData
+    class HRESULT(_SimpleCData):
+        _type_ = "l"
+        # _check_retval_ is called with the function's result when it
+        # is used as restype.  It checks for the FAILED bit, and
+        # raises an OSError if it is set.
+        #
+        # The _check_retval_ method is implemented in C, so that the
+        # method definition itself is not included in the traceback
+        # when it raises an error - that is what we want (and Python
+        # doesn't have a way to raise an exception in the caller's
+        # frame).
+        _check_retval_ = _check_HRESULT
+
+    class OleDLL(CDLL):
+        """This class represents a dll exporting functions using the
+        Windows stdcall calling convention, and returning HRESULT.
+        HRESULT error values are automatically raised as OSError
+        exceptions.
+        """
+        _func_flags_ = _FUNCFLAG_STDCALL
+        _func_restype_ = HRESULT
+
+class LibraryLoader(object):
+    def __init__(self, dlltype):
+        self._dlltype = dlltype
+
+    def __getattr__(self, name):
+        if name[0] == '_':
+            raise AttributeError(name)
+        dll = self._dlltype(name)
+        setattr(self, name, dll)
+        return dll
+
+    def __getitem__(self, name):
+        return getattr(self, name)
+
+    def LoadLibrary(self, name):
+        return self._dlltype(name)
+
+    __class_getitem__ = classmethod(_types.GenericAlias)
+
+cdll = LibraryLoader(CDLL)
+pydll = LibraryLoader(PyDLL)
+
+if _os.name == "nt":
+    pythonapi = PyDLL("python dll", None, _sys.dllhandle)
+elif _sys.platform == "cygwin":
+    pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
+else:
+    pythonapi = PyDLL(None)
+
+
+if _os.name == "nt":
+    windll = LibraryLoader(WinDLL)
+    oledll = LibraryLoader(OleDLL)
+
+    GetLastError = windll.kernel32.GetLastError
+    from _ctypes import get_last_error, set_last_error
+
+    def WinError(code=None, descr=None):
+        if code is None:
+            code = GetLastError()
+        if descr is None:
+            descr = FormatError(code).strip()
+        return OSError(None, descr, None, code)
+
+if sizeof(c_uint) == sizeof(c_void_p):
+    c_size_t = c_uint
+    c_ssize_t = c_int
+elif sizeof(c_ulong) == sizeof(c_void_p):
+    c_size_t = c_ulong
+    c_ssize_t = c_long
+elif sizeof(c_ulonglong) == sizeof(c_void_p):
+    c_size_t = c_ulonglong
+    c_ssize_t = c_longlong
+
+# functions
+
+from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
+
+## void *memmove(void *, const void *, size_t);
+memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
+
+## void *memset(void *, int, size_t)
+memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
+
+def PYFUNCTYPE(restype, *argtypes):
+    class CFunctionType(_CFuncPtr):
+        _argtypes_ = argtypes
+        _restype_ = restype
+        _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
+    return CFunctionType
+
+_cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
+def cast(obj, typ):
+    return _cast(obj, obj, typ)
+
+_string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
+def string_at(ptr, size=-1):
+    """string_at(addr[, size]) -> string
+
+    Return the string at addr."""
+    return _string_at(ptr, size)
+
+try:
+    from _ctypes import _wstring_at_addr
+except ImportError:
+    pass
+else:
+    _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
+    def wstring_at(ptr, size=-1):
+        """wstring_at(addr[, size]) -> string
+
+        Return the string at addr."""
+        return _wstring_at(ptr, size)
+
+
+if _os.name == "nt": # COM stuff
+    def DllGetClassObject(rclsid, riid, ppv):
+        try:
+            ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
+        except ImportError:
+            return -2147221231 # CLASS_E_CLASSNOTAVAILABLE
+        else:
+            return ccom.DllGetClassObject(rclsid, riid, ppv)
+
+    def DllCanUnloadNow():
+        try:
+            ccom = __import__("comtypes.server.inprocserver", globals(), locals(), ['*'])
+        except ImportError:
+            return 0 # S_OK
+        return ccom.DllCanUnloadNow()
+
+from ctypes._endian import BigEndianStructure, LittleEndianStructure
+from ctypes._endian import BigEndianUnion, LittleEndianUnion
+
+# Fill in specifically-sized types
+c_int8 = c_byte
+c_uint8 = c_ubyte
+for kind in [c_short, c_int, c_long, c_longlong]:
+    if sizeof(kind) == 2: c_int16 = kind
+    elif sizeof(kind) == 4: c_int32 = kind
+    elif sizeof(kind) == 8: c_int64 = kind
+for kind in [c_ushort, c_uint, c_ulong, c_ulonglong]:
+    if sizeof(kind) == 2: c_uint16 = kind
+    elif sizeof(kind) == 4: c_uint32 = kind
+    elif sizeof(kind) == 8: c_uint64 = kind
+del(kind)
+
+_reset_cache()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/_aix.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/_aix.py
new file mode 100644
index 0000000..fc3e95c
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/_aix.py
@@ -0,0 +1,331 @@
+"""
+Lib/ctypes.util.find_library() support for AIX
+Similar approach as done for Darwin support by using separate files
+but unlike Darwin - no extension such as ctypes.macholib.*
+
+dlopen() is an interface to AIX initAndLoad() - primary documentation at:
+https://www.ibm.com/support/knowledgecenter/en/ssw_aix_61/com.ibm.aix.basetrf1/dlopen.htm
+https://www.ibm.com/support/knowledgecenter/en/ssw_aix_61/com.ibm.aix.basetrf1/load.htm
+
+AIX supports two styles for dlopen(): svr4 (System V Release 4) which is common on posix
+platforms, but also a BSD style - aka SVR3.
+
+From AIX 5.3 Difference Addendum (December 2004)
+2.9 SVR4 linking affinity
+Nowadays, there are two major object file formats used by the operating systems:
+XCOFF: The COFF enhanced by IBM and others. The original COFF (Common
+Object File Format) was the base of SVR3 and BSD 4.2 systems.
+ELF:   Executable and Linking Format that was developed by AT&T and is a
+base for SVR4 UNIX.
+
+While the shared library content is identical on AIX - one is located as a filepath name
+(svr4 style) and the other is located as a member of an archive (and the archive
+is located as a filepath name).
+
+The key difference arises when supporting multiple abi formats (i.e., 32 and 64 bit).
+For svr4 either only one ABI is supported, or there are two directories, or there
+are different file names. The most common solution for multiple ABI is multiple
+directories.
+
+For the XCOFF (aka AIX) style - one directory (one archive file) is sufficient
+as multiple shared libraries can be in the archive - even sharing the same name.
+In documentation the archive is also referred to as the "base" and the shared
+library object is referred to as the "member".
+
+For dlopen() on AIX (read initAndLoad()) the calls are similar.
+Default activity occurs when no path information is provided. When path
+information is provided dlopen() does not search any other directories.
+
+For SVR4 - the shared library name is the name of the file expected: libFOO.so
+For AIX - the shared library is expressed as base(member). The search is for the
+base (e.g., libFOO.a) and once the base is found the shared library - identified by
+member (e.g., libFOO.so, or shr.o) is located and loaded.
+
+The mode bit RTLD_MEMBER tells initAndLoad() that it needs to use the AIX (SVR3)
+naming style.
+"""
+__author__ = "Michael Felt <aixtools@felt.demon.nl>"
+
+import re
+from os import environ, path
+from sys import executable
+from ctypes import c_void_p, sizeof
+from subprocess import Popen, PIPE, DEVNULL
+
+# Executable bit size - 32 or 64
+# Used to filter the search in an archive by size, e.g., -X64
+AIX_ABI = sizeof(c_void_p) * 8
+
+
+from sys import maxsize
+def _last_version(libnames, sep):
+    def _num_version(libname):
+        # "libxyz.so.MAJOR.MINOR" => [MAJOR, MINOR]
+        parts = libname.split(sep)
+        nums = []
+        try:
+            while parts:
+                nums.insert(0, int(parts.pop()))
+        except ValueError:
+            pass
+        return nums or [maxsize]
+    return max(reversed(libnames), key=_num_version)
+
+def get_ld_header(p):
+    # "nested-function, but placed at module level
+    ld_header = None
+    for line in p.stdout:
+        if line.startswith(('/', './', '../')):
+            ld_header = line
+        elif "INDEX" in line:
+            return ld_header.rstrip('\n')
+    return None
+
+def get_ld_header_info(p):
+    # "nested-function, but placed at module level
+    # as an ld_header was found, return known paths, archives and members
+    # these lines start with a digit
+    info = []
+    for line in p.stdout:
+        if re.match("[0-9]", line):
+            info.append(line)
+        else:
+            # blank line (separator), consume line and end for loop
+            break
+    return info
+
+def get_ld_headers(file):
+    """
+    Parse the header of the loader section of executable and archives
+    This function calls /usr/bin/dump -H as a subprocess
+    and returns a list of (ld_header, ld_header_info) tuples.
+    """
+    # get_ld_headers parsing:
+    # 1. Find a line that starts with /, ./, or ../ - set as ld_header
+    # 2. If "INDEX" in occurs in a following line - return ld_header
+    # 3. get info (lines starting with [0-9])
+    ldr_headers = []
+    p = Popen(["/usr/bin/dump", f"-X{AIX_ABI}", "-H", file],
+        universal_newlines=True, stdout=PIPE, stderr=DEVNULL)
+    # be sure to read to the end-of-file - getting all entries
+    while True:
+        ld_header = get_ld_header(p)
+        if ld_header:
+            ldr_headers.append((ld_header, get_ld_header_info(p)))
+        else:
+            break
+    p.stdout.close()
+    p.wait()
+    return ldr_headers
+
+def get_shared(ld_headers):
+    """
+    extract the shareable objects from ld_headers
+    character "[" is used to strip off the path information.
+    Note: the "[" and "]" characters that are part of dump -H output
+    are not removed here.
+    """
+    shared = []
+    for (line, _) in ld_headers:
+        # potential member lines contain "["
+        # otherwise, no processing needed
+        if "[" in line:
+            # Strip off trailing colon (:)
+            shared.append(line[line.index("["):-1])
+    return shared
+
+def get_one_match(expr, lines):
+    """
+    Must be only one match, otherwise result is None.
+    When there is a match, strip leading "[" and trailing "]"
+    """
+    # member names in the ld_headers output are between square brackets
+    expr = rf'\[({expr})\]'
+    matches = list(filter(None, (re.search(expr, line) for line in lines)))
+    if len(matches) == 1:
+        return matches[0].group(1)
+    else:
+        return None
+
+# additional processing to deal with AIX legacy names for 64-bit members
+def get_legacy(members):
+    """
+    This routine provides historical aka legacy naming schemes started
+    in AIX4 shared library support for library members names.
+    e.g., in /usr/lib/libc.a the member name shr.o for 32-bit binary and
+    shr_64.o for 64-bit binary.
+    """
+    if AIX_ABI == 64:
+        # AIX 64-bit member is one of shr64.o, shr_64.o, or shr4_64.o
+        expr = r'shr4?_?64\.o'
+        member = get_one_match(expr, members)
+        if member:
+            return member
+    else:
+        # 32-bit legacy names - both shr.o and shr4.o exist.
+        # shr.o is the preferred name so we look for shr.o first
+        #  i.e., shr4.o is returned only when shr.o does not exist
+        for name in ['shr.o', 'shr4.o']:
+            member = get_one_match(re.escape(name), members)
+            if member:
+                return member
+    return None
+
+def get_version(name, members):
+    """
+    Sort list of members and return highest numbered version - if it exists.
+    This function is called when an unversioned libFOO.a(libFOO.so) has
+    not been found.
+
+    Versioning for the member name is expected to follow
+    GNU LIBTOOL conventions: the highest version (x, then X.y, then X.Y.z)
+     * find [libFoo.so.X]
+     * find [libFoo.so.X.Y]
+     * find [libFoo.so.X.Y.Z]
+
+    Before the GNU convention became the standard scheme regardless of
+    binary size AIX packagers used GNU convention "as-is" for 32-bit
+    archive members but used an "distinguishing" name for 64-bit members.
+    This scheme inserted either 64 or _64 between libFOO and .so
+    - generally libFOO_64.so, but occasionally libFOO64.so
+    """
+    # the expression ending for versions must start as
+    # '.so.[0-9]', i.e., *.so.[at least one digit]
+    # while multiple, more specific expressions could be specified
+    # to search for .so.X, .so.X.Y and .so.X.Y.Z
+    # after the first required 'dot' digit
+    # any combination of additional 'dot' digits pairs are accepted
+    # anything more than libFOO.so.digits.digits.digits
+    # should be seen as a member name outside normal expectations
+    exprs = [rf'lib{name}\.so\.[0-9]+[0-9.]*',
+        rf'lib{name}_?64\.so\.[0-9]+[0-9.]*']
+    for expr in exprs:
+        versions = []
+        for line in members:
+            m = re.search(expr, line)
+            if m:
+                versions.append(m.group(0))
+        if versions:
+            return _last_version(versions, '.')
+    return None
+
+def get_member(name, members):
+    """
+    Return an archive member matching the request in name.
+    Name is the library name without any prefix like lib, suffix like .so,
+    or version number.
+    Given a list of members find and return the most appropriate result
+    Priority is given to generic libXXX.so, then a versioned libXXX.so.a.b.c
+    and finally, legacy AIX naming scheme.
+    """
+    # look first for a generic match - prepend lib and append .so
+    expr = rf'lib{name}\.so'
+    member = get_one_match(expr, members)
+    if member:
+        return member
+    elif AIX_ABI == 64:
+        expr = rf'lib{name}64\.so'
+        member = get_one_match(expr, members)
+    if member:
+        return member
+    # since an exact match with .so as suffix was not found
+    # look for a versioned name
+    # If a versioned name is not found, look for AIX legacy member name
+    member = get_version(name, members)
+    if member:
+        return member
+    else:
+        return get_legacy(members)
+
+def get_libpaths():
+    """
+    On AIX, the buildtime searchpath is stored in the executable.
+    as "loader header information".
+    The command /usr/bin/dump -H extracts this info.
+    Prefix searched libraries with LD_LIBRARY_PATH (preferred),
+    or LIBPATH if defined. These paths are appended to the paths
+    to libraries the python executable is linked with.
+    This mimics AIX dlopen() behavior.
+    """
+    libpaths = environ.get("LD_LIBRARY_PATH")
+    if libpaths is None:
+        libpaths = environ.get("LIBPATH")
+    if libpaths is None:
+        libpaths = []
+    else:
+        libpaths = libpaths.split(":")
+    objects = get_ld_headers(executable)
+    for (_, lines) in objects:
+        for line in lines:
+            # the second (optional) argument is PATH if it includes a /
+            path = line.split()[1]
+            if "/" in path:
+                libpaths.extend(path.split(":"))
+    return libpaths
+
+def find_shared(paths, name):
+    """
+    paths is a list of directories to search for an archive.
+    name is the abbreviated name given to find_library().
+    Process: search "paths" for archive, and if an archive is found
+    return the result of get_member().
+    If an archive is not found then return None
+    """
+    for dir in paths:
+        # /lib is a symbolic link to /usr/lib, skip it
+        if dir == "/lib":
+            continue
+        # "lib" is prefixed to emulate compiler name resolution,
+        # e.g., -lc to libc
+        base = f'lib{name}.a'
+        archive = path.join(dir, base)
+        if path.exists(archive):
+            members = get_shared(get_ld_headers(archive))
+            member = get_member(re.escape(name), members)
+            if member is not None:
+                return (base, member)
+            else:
+                return (None, None)
+    return (None, None)
+
+def find_library(name):
+    """AIX implementation of ctypes.util.find_library()
+    Find an archive member that will dlopen(). If not available,
+    also search for a file (or link) with a .so suffix.
+
+    AIX supports two types of schemes that can be used with dlopen().
+    The so-called SystemV Release4 (svr4) format is commonly suffixed
+    with .so while the (default) AIX scheme has the library (archive)
+    ending with the suffix .a
+    As an archive has multiple members (e.g., 32-bit and 64-bit) in one file
+    the argument passed to dlopen must include both the library and
+    the member names in a single string.
+
+    find_library() looks first for an archive (.a) with a suitable member.
+    If no archive+member pair is found, look for a .so file.
+    """
+
+    libpaths = get_libpaths()
+    (base, member) = find_shared(libpaths, name)
+    if base is not None:
+        return f"{base}({member})"
+
+    # To get here, a member in an archive has not been found
+    # In other words, either:
+    # a) a .a file was not found
+    # b) a .a file did not have a suitable member
+    # So, look for a .so file
+    # Check libpaths for .so file
+    # Note, the installation must prepare a link from a .so
+    # to a versioned file
+    # This is common practice by GNU libtool on other platforms
+    soname = f"lib{name}.so"
+    for dir in libpaths:
+        # /lib is a symbolic link to /usr/lib, skip it
+        if dir == "/lib":
+            continue
+        shlib = path.join(dir, soname)
+        if path.exists(shlib):
+            return soname
+    # if we are here, we have not found anything plausible
+    return None
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/_endian.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/_endian.py
new file mode 100644
index 0000000..34dee64
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/_endian.py
@@ -0,0 +1,78 @@
+import sys
+from ctypes import *
+
+_array_type = type(Array)
+
+def _other_endian(typ):
+    """Return the type with the 'other' byte order.  Simple types like
+    c_int and so on already have __ctype_be__ and __ctype_le__
+    attributes which contain the types, for more complicated types
+    arrays and structures are supported.
+    """
+    # check _OTHER_ENDIAN attribute (present if typ is primitive type)
+    if hasattr(typ, _OTHER_ENDIAN):
+        return getattr(typ, _OTHER_ENDIAN)
+    # if typ is array
+    if isinstance(typ, _array_type):
+        return _other_endian(typ._type_) * typ._length_
+    # if typ is structure
+    if issubclass(typ, Structure):
+        return typ
+    raise TypeError("This type does not support other endian: %s" % typ)
+
+class _swapped_meta:
+    def __setattr__(self, attrname, value):
+        if attrname == "_fields_":
+            fields = []
+            for desc in value:
+                name = desc[0]
+                typ = desc[1]
+                rest = desc[2:]
+                fields.append((name, _other_endian(typ)) + rest)
+            value = fields
+        super().__setattr__(attrname, value)
+class _swapped_struct_meta(_swapped_meta, type(Structure)): pass
+class _swapped_union_meta(_swapped_meta, type(Union)): pass
+
+################################################################
+
+# Note: The Structure metaclass checks for the *presence* (not the
+# value!) of a _swapped_bytes_ attribute to determine the bit order in
+# structures containing bit fields.
+
+if sys.byteorder == "little":
+    _OTHER_ENDIAN = "__ctype_be__"
+
+    LittleEndianStructure = Structure
+
+    class BigEndianStructure(Structure, metaclass=_swapped_struct_meta):
+        """Structure with big endian byte order"""
+        __slots__ = ()
+        _swappedbytes_ = None
+
+    LittleEndianUnion = Union
+
+    class BigEndianUnion(Union, metaclass=_swapped_union_meta):
+        """Union with big endian byte order"""
+        __slots__ = ()
+        _swappedbytes_ = None
+
+elif sys.byteorder == "big":
+    _OTHER_ENDIAN = "__ctype_le__"
+
+    BigEndianStructure = Structure
+
+    class LittleEndianStructure(Structure, metaclass=_swapped_struct_meta):
+        """Structure with little endian byte order"""
+        __slots__ = ()
+        _swappedbytes_ = None
+
+    BigEndianUnion = Union
+
+    class LittleEndianUnion(Union, metaclass=_swapped_union_meta):
+        """Union with little endian byte order"""
+        __slots__ = ()
+        _swappedbytes_ = None
+
+else:
+    raise RuntimeError("Invalid byteorder")
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/README.ctypes b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/README.ctypes
new file mode 100644
index 0000000..2866e9f
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/README.ctypes
@@ -0,0 +1,7 @@
+Files in this directory come from Bob Ippolito's py2app.
+
+License: Any components of the py2app suite may be distributed under
+the MIT or PSF open source licenses.
+
+This is version 1.0, SVN revision 789, from 2006/01/25.
+The main repository is http://svn.red-bean.com/bob/macholib/trunk/macholib/
\ No newline at end of file
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/__init__.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/__init__.py
new file mode 100644
index 0000000..5621def
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/__init__.py
@@ -0,0 +1,9 @@
+"""
+Enough Mach-O to make your head spin.
+
+See the relevant header files in /usr/include/mach-o
+
+And also Apple's documentation.
+"""
+
+__version__ = '1.0'
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dyld.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dyld.py
new file mode 100644
index 0000000..583c47d
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dyld.py
@@ -0,0 +1,165 @@
+"""
+dyld emulation
+"""
+
+import os
+from ctypes.macholib.framework import framework_info
+from ctypes.macholib.dylib import dylib_info
+from itertools import *
+try:
+    from _ctypes import _dyld_shared_cache_contains_path
+except ImportError:
+    def _dyld_shared_cache_contains_path(*args):
+        raise NotImplementedError
+
+__all__ = [
+    'dyld_find', 'framework_find',
+    'framework_info', 'dylib_info',
+]
+
+# These are the defaults as per man dyld(1)
+#
+DEFAULT_FRAMEWORK_FALLBACK = [
+    os.path.expanduser("~/Library/Frameworks"),
+    "/Library/Frameworks",
+    "/Network/Library/Frameworks",
+    "/System/Library/Frameworks",
+]
+
+DEFAULT_LIBRARY_FALLBACK = [
+    os.path.expanduser("~/lib"),
+    "/usr/local/lib",
+    "/lib",
+    "/usr/lib",
+]
+
+def dyld_env(env, var):
+    if env is None:
+        env = os.environ
+    rval = env.get(var)
+    if rval is None:
+        return []
+    return rval.split(':')
+
+def dyld_image_suffix(env=None):
+    if env is None:
+        env = os.environ
+    return env.get('DYLD_IMAGE_SUFFIX')
+
+def dyld_framework_path(env=None):
+    return dyld_env(env, 'DYLD_FRAMEWORK_PATH')
+
+def dyld_library_path(env=None):
+    return dyld_env(env, 'DYLD_LIBRARY_PATH')
+
+def dyld_fallback_framework_path(env=None):
+    return dyld_env(env, 'DYLD_FALLBACK_FRAMEWORK_PATH')
+
+def dyld_fallback_library_path(env=None):
+    return dyld_env(env, 'DYLD_FALLBACK_LIBRARY_PATH')
+
+def dyld_image_suffix_search(iterator, env=None):
+    """For a potential path iterator, add DYLD_IMAGE_SUFFIX semantics"""
+    suffix = dyld_image_suffix(env)
+    if suffix is None:
+        return iterator
+    def _inject(iterator=iterator, suffix=suffix):
+        for path in iterator:
+            if path.endswith('.dylib'):
+                yield path[:-len('.dylib')] + suffix + '.dylib'
+            else:
+                yield path + suffix
+            yield path
+    return _inject()
+
+def dyld_override_search(name, env=None):
+    # If DYLD_FRAMEWORK_PATH is set and this dylib_name is a
+    # framework name, use the first file that exists in the framework
+    # path if any.  If there is none go on to search the DYLD_LIBRARY_PATH
+    # if any.
+
+    framework = framework_info(name)
+
+    if framework is not None:
+        for path in dyld_framework_path(env):
+            yield os.path.join(path, framework['name'])
+
+    # If DYLD_LIBRARY_PATH is set then use the first file that exists
+    # in the path.  If none use the original name.
+    for path in dyld_library_path(env):
+        yield os.path.join(path, os.path.basename(name))
+
+def dyld_executable_path_search(name, executable_path=None):
+    # If we haven't done any searching and found a library and the
+    # dylib_name starts with "@executable_path/" then construct the
+    # library name.
+    if name.startswith('@executable_path/') and executable_path is not None:
+        yield os.path.join(executable_path, name[len('@executable_path/'):])
+
+def dyld_default_search(name, env=None):
+    yield name
+
+    framework = framework_info(name)
+
+    if framework is not None:
+        fallback_framework_path = dyld_fallback_framework_path(env)
+        for path in fallback_framework_path:
+            yield os.path.join(path, framework['name'])
+
+    fallback_library_path = dyld_fallback_library_path(env)
+    for path in fallback_library_path:
+        yield os.path.join(path, os.path.basename(name))
+
+    if framework is not None and not fallback_framework_path:
+        for path in DEFAULT_FRAMEWORK_FALLBACK:
+            yield os.path.join(path, framework['name'])
+
+    if not fallback_library_path:
+        for path in DEFAULT_LIBRARY_FALLBACK:
+            yield os.path.join(path, os.path.basename(name))
+
+def dyld_find(name, executable_path=None, env=None):
+    """
+    Find a library or framework using dyld semantics
+    """
+    for path in dyld_image_suffix_search(chain(
+                dyld_override_search(name, env),
+                dyld_executable_path_search(name, executable_path),
+                dyld_default_search(name, env),
+            ), env):
+
+        if os.path.isfile(path):
+            return path
+        try:
+            if _dyld_shared_cache_contains_path(path):
+                return path
+        except NotImplementedError:
+            pass
+
+    raise ValueError("dylib %s could not be found" % (name,))
+
+def framework_find(fn, executable_path=None, env=None):
+    """
+    Find a framework using dyld semantics in a very loose manner.
+
+    Will take input such as:
+        Python
+        Python.framework
+        Python.framework/Versions/Current
+    """
+    error = None
+    try:
+        return dyld_find(fn, executable_path=executable_path, env=env)
+    except ValueError as e:
+        error = e
+    fmwk_index = fn.rfind('.framework')
+    if fmwk_index == -1:
+        fmwk_index = len(fn)
+        fn += '.framework'
+    fn = os.path.join(fn, os.path.basename(fn[:fmwk_index]))
+    try:
+        return dyld_find(fn, executable_path=executable_path, env=env)
+    except ValueError:
+        raise error
+    finally:
+        error = None
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dylib.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dylib.py
new file mode 100644
index 0000000..0ad4cba
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/dylib.py
@@ -0,0 +1,42 @@
+"""
+Generic dylib path manipulation
+"""
+
+import re
+
+__all__ = ['dylib_info']
+
+DYLIB_RE = re.compile(r"""(?x)
+(?P<location>^.*)(?:^|/)
+(?P<name>
+    (?P<shortname>\w+?)
+    (?:\.(?P<version>[^._]+))?
+    (?:_(?P<suffix>[^._]+))?
+    \.dylib$
+)
+""")
+
+def dylib_info(filename):
+    """
+    A dylib name can take one of the following four forms:
+        Location/Name.SomeVersion_Suffix.dylib
+        Location/Name.SomeVersion.dylib
+        Location/Name_Suffix.dylib
+        Location/Name.dylib
+
+    returns None if not found or a mapping equivalent to:
+        dict(
+            location='Location',
+            name='Name.SomeVersion_Suffix.dylib',
+            shortname='Name',
+            version='SomeVersion',
+            suffix='Suffix',
+        )
+
+    Note that SomeVersion and Suffix are optional and may be None
+    if not present.
+    """
+    is_dylib = DYLIB_RE.match(filename)
+    if not is_dylib:
+        return None
+    return is_dylib.groupdict()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib
new file mode 100644
index 0000000..e6d6a22
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib
@@ -0,0 +1,2 @@
+#!/bin/sh
+svn export --force http://svn.red-bean.com/bob/macholib/trunk/macholib/ .
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib.bat b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib.bat
new file mode 100644
index 0000000..f9e1c0d
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/fetch_macholib.bat
@@ -0,0 +1 @@
+svn export --force http://svn.red-bean.com/bob/macholib/trunk/macholib/ .
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/framework.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/framework.py
new file mode 100644
index 0000000..495679f
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/macholib/framework.py
@@ -0,0 +1,42 @@
+"""
+Generic framework path manipulation
+"""
+
+import re
+
+__all__ = ['framework_info']
+
+STRICT_FRAMEWORK_RE = re.compile(r"""(?x)
+(?P<location>^.*)(?:^|/)
+(?P<name>
+    (?P<shortname>\w+).framework/
+    (?:Versions/(?P<version>[^/]+)/)?
+    (?P=shortname)
+    (?:_(?P<suffix>[^_]+))?
+)$
+""")
+
+def framework_info(filename):
+    """
+    A framework name can take one of the following four forms:
+        Location/Name.framework/Versions/SomeVersion/Name_Suffix
+        Location/Name.framework/Versions/SomeVersion/Name
+        Location/Name.framework/Name_Suffix
+        Location/Name.framework/Name
+
+    returns None if not found, or a mapping equivalent to:
+        dict(
+            location='Location',
+            name='Name.framework/Versions/SomeVersion/Name_Suffix',
+            shortname='Name',
+            version='SomeVersion',
+            suffix='Suffix',
+        )
+
+    Note that SomeVersion and Suffix are optional and may be None
+    if not present
+    """
+    is_framework = STRICT_FRAMEWORK_RE.match(filename)
+    if not is_framework:
+        return None
+    return is_framework.groupdict()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__init__.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__init__.py
new file mode 100644
index 0000000..6e496fa
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__init__.py
@@ -0,0 +1,16 @@
+import os
+import unittest
+from test import support
+from test.support import import_helper
+
+
+# skip tests if _ctypes was not built
+ctypes = import_helper.import_module('ctypes')
+ctypes_symbols = dir(ctypes)
+
+def need_symbol(name):
+    return unittest.skipUnless(name in ctypes_symbols,
+                               '{!r} is required'.format(name))
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__main__.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__main__.py
new file mode 100644
index 0000000..362a9ec
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/__main__.py
@@ -0,0 +1,4 @@
+from ctypes.test import load_tests
+import unittest
+
+unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_anon.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_anon.py
new file mode 100644
index 0000000..d378392
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_anon.py
@@ -0,0 +1,73 @@
+import unittest
+import test.support
+from ctypes import *
+
+class AnonTest(unittest.TestCase):
+
+    def test_anon(self):
+        class ANON(Union):
+            _fields_ = [("a", c_int),
+                        ("b", c_int)]
+
+        class Y(Structure):
+            _fields_ = [("x", c_int),
+                        ("_", ANON),
+                        ("y", c_int)]
+            _anonymous_ = ["_"]
+
+        self.assertEqual(Y.a.offset, sizeof(c_int))
+        self.assertEqual(Y.b.offset, sizeof(c_int))
+
+        self.assertEqual(ANON.a.offset, 0)
+        self.assertEqual(ANON.b.offset, 0)
+
+    def test_anon_nonseq(self):
+        # TypeError: _anonymous_ must be a sequence
+        self.assertRaises(TypeError,
+                              lambda: type(Structure)("Name",
+                                                      (Structure,),
+                                                      {"_fields_": [], "_anonymous_": 42}))
+
+    def test_anon_nonmember(self):
+        # AttributeError: type object 'Name' has no attribute 'x'
+        self.assertRaises(AttributeError,
+                              lambda: type(Structure)("Name",
+                                                      (Structure,),
+                                                      {"_fields_": [],
+                                                       "_anonymous_": ["x"]}))
+
+    @test.support.cpython_only
+    def test_issue31490(self):
+        # There shouldn't be an assertion failure in case the class has an
+        # attribute whose name is specified in _anonymous_ but not in _fields_.
+
+        # AttributeError: 'x' is specified in _anonymous_ but not in _fields_
+        with self.assertRaises(AttributeError):
+            class Name(Structure):
+                _fields_ = []
+                _anonymous_ = ["x"]
+                x = 42
+
+    def test_nested(self):
+        class ANON_S(Structure):
+            _fields_ = [("a", c_int)]
+
+        class ANON_U(Union):
+            _fields_ = [("_", ANON_S),
+                        ("b", c_int)]
+            _anonymous_ = ["_"]
+
+        class Y(Structure):
+            _fields_ = [("x", c_int),
+                        ("_", ANON_U),
+                        ("y", c_int)]
+            _anonymous_ = ["_"]
+
+        self.assertEqual(Y.x.offset, 0)
+        self.assertEqual(Y.a.offset, sizeof(c_int))
+        self.assertEqual(Y.b.offset, sizeof(c_int))
+        self.assertEqual(Y._.offset, sizeof(c_int))
+        self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_array_in_pointer.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_array_in_pointer.py
new file mode 100644
index 0000000..ca1edcf
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_array_in_pointer.py
@@ -0,0 +1,64 @@
+import unittest
+from ctypes import *
+from binascii import hexlify
+import re
+
+def dump(obj):
+    # helper function to dump memory contents in hex, with a hyphen
+    # between the bytes.
+    h = hexlify(memoryview(obj)).decode()
+    return re.sub(r"(..)", r"\1-", h)[:-1]
+
+
+class Value(Structure):
+    _fields_ = [("val", c_byte)]
+
+class Container(Structure):
+    _fields_ = [("pvalues", POINTER(Value))]
+
+class Test(unittest.TestCase):
+    def test(self):
+        # create an array of 4 values
+        val_array = (Value * 4)()
+
+        # create a container, which holds a pointer to the pvalues array.
+        c = Container()
+        c.pvalues = val_array
+
+        # memory contains 4 NUL bytes now, that's correct
+        self.assertEqual("00-00-00-00", dump(val_array))
+
+        # set the values of the array through the pointer:
+        for i in range(4):
+            c.pvalues[i].val = i + 1
+
+        values = [c.pvalues[i].val for i in range(4)]
+
+        # These are the expected results: here s the bug!
+        self.assertEqual(
+            (values, dump(val_array)),
+            ([1, 2, 3, 4], "01-02-03-04")
+        )
+
+    def test_2(self):
+
+        val_array = (Value * 4)()
+
+        # memory contains 4 NUL bytes now, that's correct
+        self.assertEqual("00-00-00-00", dump(val_array))
+
+        ptr = cast(val_array, POINTER(Value))
+        # set the values of the array through the pointer:
+        for i in range(4):
+            ptr[i].val = i + 1
+
+        values = [ptr[i].val for i in range(4)]
+
+        # These are the expected results: here s the bug!
+        self.assertEqual(
+            (values, dump(val_array)),
+            ([1, 2, 3, 4], "01-02-03-04")
+        )
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_arrays.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_arrays.py
new file mode 100644
index 0000000..14603b7
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_arrays.py
@@ -0,0 +1,238 @@
+import unittest
+from test.support import bigmemtest, _2G
+import sys
+from ctypes import *
+
+from ctypes.test import need_symbol
+
+formats = "bBhHiIlLqQfd"
+
+formats = c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint, \
+          c_long, c_ulonglong, c_float, c_double, c_longdouble
+
+class ArrayTestCase(unittest.TestCase):
+    def test_simple(self):
+        # create classes holding simple numeric types, and check
+        # various properties.
+
+        init = list(range(15, 25))
+
+        for fmt in formats:
+            alen = len(init)
+            int_array = ARRAY(fmt, alen)
+
+            ia = int_array(*init)
+            # length of instance ok?
+            self.assertEqual(len(ia), alen)
+
+            # slot values ok?
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, init)
+
+            # out-of-bounds accesses should be caught
+            with self.assertRaises(IndexError): ia[alen]
+            with self.assertRaises(IndexError): ia[-alen-1]
+
+            # change the items
+            from operator import setitem
+            new_values = list(range(42, 42+alen))
+            [setitem(ia, n, new_values[n]) for n in range(alen)]
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, new_values)
+
+            # are the items initialized to 0?
+            ia = int_array()
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, [0] * alen)
+
+            # Too many initializers should be caught
+            self.assertRaises(IndexError, int_array, *range(alen*2))
+
+        CharArray = ARRAY(c_char, 3)
+
+        ca = CharArray(b"a", b"b", b"c")
+
+        # Should this work? It doesn't:
+        # CharArray("abc")
+        self.assertRaises(TypeError, CharArray, "abc")
+
+        self.assertEqual(ca[0], b"a")
+        self.assertEqual(ca[1], b"b")
+        self.assertEqual(ca[2], b"c")
+        self.assertEqual(ca[-3], b"a")
+        self.assertEqual(ca[-2], b"b")
+        self.assertEqual(ca[-1], b"c")
+
+        self.assertEqual(len(ca), 3)
+
+        # cannot delete items
+        from operator import delitem
+        self.assertRaises(TypeError, delitem, ca, 0)
+
+    def test_step_overflow(self):
+        a = (c_int * 5)()
+        a[3::sys.maxsize] = (1,)
+        self.assertListEqual(a[3::sys.maxsize], [1])
+        a = (c_char * 5)()
+        a[3::sys.maxsize] = b"A"
+        self.assertEqual(a[3::sys.maxsize], b"A")
+        a = (c_wchar * 5)()
+        a[3::sys.maxsize] = u"X"
+        self.assertEqual(a[3::sys.maxsize], u"X")
+
+    def test_numeric_arrays(self):
+
+        alen = 5
+
+        numarray = ARRAY(c_int, alen)
+
+        na = numarray()
+        values = [na[i] for i in range(alen)]
+        self.assertEqual(values, [0] * alen)
+
+        na = numarray(*[c_int()] * alen)
+        values = [na[i] for i in range(alen)]
+        self.assertEqual(values, [0]*alen)
+
+        na = numarray(1, 2, 3, 4, 5)
+        values = [i for i in na]
+        self.assertEqual(values, [1, 2, 3, 4, 5])
+
+        na = numarray(*map(c_int, (1, 2, 3, 4, 5)))
+        values = [i for i in na]
+        self.assertEqual(values, [1, 2, 3, 4, 5])
+
+    def test_classcache(self):
+        self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4))
+        self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3))
+
+    def test_from_address(self):
+        # Failed with 0.9.8, reported by JUrner
+        p = create_string_buffer(b"foo")
+        sz = (c_char * 3).from_address(addressof(p))
+        self.assertEqual(sz[:], b"foo")
+        self.assertEqual(sz[::], b"foo")
+        self.assertEqual(sz[::-1], b"oof")
+        self.assertEqual(sz[::3], b"f")
+        self.assertEqual(sz[1:4:2], b"o")
+        self.assertEqual(sz.value, b"foo")
+
+    @need_symbol('create_unicode_buffer')
+    def test_from_addressW(self):
+        p = create_unicode_buffer("foo")
+        sz = (c_wchar * 3).from_address(addressof(p))
+        self.assertEqual(sz[:], "foo")
+        self.assertEqual(sz[::], "foo")
+        self.assertEqual(sz[::-1], "oof")
+        self.assertEqual(sz[::3], "f")
+        self.assertEqual(sz[1:4:2], "o")
+        self.assertEqual(sz.value, "foo")
+
+    def test_cache(self):
+        # Array types are cached internally in the _ctypes extension,
+        # in a WeakValueDictionary.  Make sure the array type is
+        # removed from the cache when the itemtype goes away.  This
+        # test will not fail, but will show a leak in the testsuite.
+
+        # Create a new type:
+        class my_int(c_int):
+            pass
+        # Create a new array type based on it:
+        t1 = my_int * 1
+        t2 = my_int * 1
+        self.assertIs(t1, t2)
+
+    def test_subclass(self):
+        class T(Array):
+            _type_ = c_int
+            _length_ = 13
+        class U(T):
+            pass
+        class V(U):
+            pass
+        class W(V):
+            pass
+        class X(T):
+            _type_ = c_short
+        class Y(T):
+            _length_ = 187
+
+        for c in [T, U, V, W]:
+            self.assertEqual(c._type_, c_int)
+            self.assertEqual(c._length_, 13)
+            self.assertEqual(c()._type_, c_int)
+            self.assertEqual(c()._length_, 13)
+
+        self.assertEqual(X._type_, c_short)
+        self.assertEqual(X._length_, 13)
+        self.assertEqual(X()._type_, c_short)
+        self.assertEqual(X()._length_, 13)
+
+        self.assertEqual(Y._type_, c_int)
+        self.assertEqual(Y._length_, 187)
+        self.assertEqual(Y()._type_, c_int)
+        self.assertEqual(Y()._length_, 187)
+
+    def test_bad_subclass(self):
+        with self.assertRaises(AttributeError):
+            class T(Array):
+                pass
+        with self.assertRaises(AttributeError):
+            class T(Array):
+                _type_ = c_int
+        with self.assertRaises(AttributeError):
+            class T(Array):
+                _length_ = 13
+
+    def test_bad_length(self):
+        with self.assertRaises(ValueError):
+            class T(Array):
+                _type_ = c_int
+                _length_ = - sys.maxsize * 2
+        with self.assertRaises(ValueError):
+            class T(Array):
+                _type_ = c_int
+                _length_ = -1
+        with self.assertRaises(TypeError):
+            class T(Array):
+                _type_ = c_int
+                _length_ = 1.87
+        with self.assertRaises(OverflowError):
+            class T(Array):
+                _type_ = c_int
+                _length_ = sys.maxsize * 2
+
+    def test_zero_length(self):
+        # _length_ can be zero.
+        class T(Array):
+            _type_ = c_int
+            _length_ = 0
+
+    def test_empty_element_struct(self):
+        class EmptyStruct(Structure):
+            _fields_ = []
+
+        obj = (EmptyStruct * 2)()  # bpo37188: Floating point exception
+        self.assertEqual(sizeof(obj), 0)
+
+    def test_empty_element_array(self):
+        class EmptyArray(Array):
+            _type_ = c_int
+            _length_ = 0
+
+        obj = (EmptyArray * 2)()  # bpo37188: Floating point exception
+        self.assertEqual(sizeof(obj), 0)
+
+    def test_bpo36504_signed_int_overflow(self):
+        # The overflow check in PyCArrayType_new() could cause signed integer
+        # overflow.
+        with self.assertRaises(OverflowError):
+            c_char * sys.maxsize * 2
+
+    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
+    @bigmemtest(size=_2G, memuse=1, dry_run=False)
+    def test_large_array(self, size):
+        c_char * size
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_as_parameter.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_as_parameter.py
new file mode 100644
index 0000000..aaaf6e2
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_as_parameter.py
@@ -0,0 +1,231 @@
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+import _ctypes_test
+
+dll = CDLL(_ctypes_test.__file__)
+
+try:
+    CALLBACK_FUNCTYPE = WINFUNCTYPE
+except NameError:
+    # fake to enable this test on Linux
+    CALLBACK_FUNCTYPE = CFUNCTYPE
+
+class POINT(Structure):
+    _fields_ = [("x", c_int), ("y", c_int)]
+
+class BasicWrapTestCase(unittest.TestCase):
+    def wrap(self, param):
+        return param
+
+    @need_symbol('c_wchar')
+    def test_wchar_parm(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
+        result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
+        self.assertEqual(result, 139)
+        self.assertIs(type(result), int)
+
+    def test_pointers(self):
+        f = dll._testfunc_p_p
+        f.restype = POINTER(c_int)
+        f.argtypes = [POINTER(c_int)]
+
+        # This only works if the value c_int(42) passed to the
+        # function is still alive while the pointer (the result) is
+        # used.
+
+        v = c_int(42)
+
+        self.assertEqual(pointer(v).contents.value, 42)
+        result = f(self.wrap(pointer(v)))
+        self.assertEqual(type(result), POINTER(c_int))
+        self.assertEqual(result.contents.value, 42)
+
+        # This on works...
+        result = f(self.wrap(pointer(v)))
+        self.assertEqual(result.contents.value, v.value)
+
+        p = pointer(c_int(99))
+        result = f(self.wrap(p))
+        self.assertEqual(result.contents.value, 99)
+
+    def test_shorts(self):
+        f = dll._testfunc_callback_i_if
+
+        args = []
+        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
+                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+
+        def callback(v):
+            args.append(v)
+            return v
+
+        CallBack = CFUNCTYPE(c_int, c_int)
+
+        cb = CallBack(callback)
+        f(self.wrap(2**18), self.wrap(cb))
+        self.assertEqual(args, expected)
+
+    ################################################################
+
+    def test_callbacks(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+        f.argtypes = None
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        def callback(value):
+            #print "called back with", value
+            return value
+
+        cb = MyCallback(callback)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        # test with prototype
+        f.argtypes = [c_int, MyCallback]
+        cb = MyCallback(callback)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int)
+
+        # check that the prototype works: we call f with wrong
+        # argument types
+        cb = AnotherCallback(callback)
+        self.assertRaises(ArgumentError, f, self.wrap(-10), self.wrap(cb))
+
+    def test_callbacks_2(self):
+        # Can also use simple datatypes as argument type specifiers
+        # for the callback function.
+        # In this case the call receives an instance of that type
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        f.argtypes = [c_int, MyCallback]
+
+        def callback(value):
+            #print "called back with", value
+            self.assertEqual(type(value), int)
+            return value
+
+        cb = MyCallback(callback)
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+    @need_symbol('c_longlong')
+    def test_longlong_callbacks(self):
+
+        f = dll._testfunc_callback_q_qf
+        f.restype = c_longlong
+
+        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
+
+        f.argtypes = [c_longlong, MyCallback]
+
+        def callback(value):
+            self.assertIsInstance(value, int)
+            return value & 0x7FFFFFFF
+
+        cb = MyCallback(callback)
+
+        self.assertEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb))))
+
+    def test_byval(self):
+        # without prototype
+        ptin = POINT(1, 2)
+        ptout = POINT()
+        # EXPORT int _testfunc_byval(point in, point *pout)
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 3, 1, 2
+        self.assertEqual(got, expected)
+
+        # with prototype
+        ptin = POINT(101, 102)
+        ptout = POINT()
+        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
+        dll._testfunc_byval.restype = c_int
+        result = dll._testfunc_byval(self.wrap(ptin), byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 203, 101, 102
+        self.assertEqual(got, expected)
+
+    def test_struct_return_2H(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+        dll.ret_2h_func.restype = S2H
+        dll.ret_2h_func.argtypes = [S2H]
+        inp = S2H(99, 88)
+        s2h = dll.ret_2h_func(self.wrap(inp))
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+        # Test also that the original struct was unmodified (i.e. was passed by
+        # value)
+        self.assertEqual((inp.x, inp.y), (99, 88))
+
+    def test_struct_return_8H(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        dll.ret_8i_func.restype = S8I
+        dll.ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = dll.ret_8i_func(self.wrap(inp))
+        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    def test_recursive_as_param(self):
+        from ctypes import c_int
+
+        class A:
+            pass
+
+        a = A()
+        a._as_parameter_ = a
+        with self.assertRaises(RecursionError):
+            c_int.from_param(a)
+
+
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class AsParamWrapper:
+    def __init__(self, param):
+        self._as_parameter_ = param
+
+class AsParamWrapperTestCase(BasicWrapTestCase):
+    wrap = AsParamWrapper
+
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class AsParamPropertyWrapper:
+    def __init__(self, param):
+        self._param = param
+
+    def getParameter(self):
+        return self._param
+    _as_parameter_ = property(getParameter)
+
+class AsParamPropertyWrapperTestCase(BasicWrapTestCase):
+    wrap = AsParamPropertyWrapper
+
+#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bitfields.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bitfields.py
new file mode 100644
index 0000000..66acd62
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bitfields.py
@@ -0,0 +1,297 @@
+from ctypes import *
+from ctypes.test import need_symbol
+from test import support
+import unittest
+import os
+
+import _ctypes_test
+
+class BITS(Structure):
+    _fields_ = [("A", c_int, 1),
+                ("B", c_int, 2),
+                ("C", c_int, 3),
+                ("D", c_int, 4),
+                ("E", c_int, 5),
+                ("F", c_int, 6),
+                ("G", c_int, 7),
+                ("H", c_int, 8),
+                ("I", c_int, 9),
+
+                ("M", c_short, 1),
+                ("N", c_short, 2),
+                ("O", c_short, 3),
+                ("P", c_short, 4),
+                ("Q", c_short, 5),
+                ("R", c_short, 6),
+                ("S", c_short, 7)]
+
+func = CDLL(_ctypes_test.__file__).unpack_bitfields
+func.argtypes = POINTER(BITS), c_char
+
+##for n in "ABCDEFGHIMNOPQRS":
+##    print n, hex(getattr(BITS, n).size), getattr(BITS, n).offset
+
+class C_Test(unittest.TestCase):
+
+    def test_ints(self):
+        for i in range(512):
+            for name in "ABCDEFGHI":
+                b = BITS()
+                setattr(b, name, i)
+                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
+
+    # bpo-46913: _ctypes/cfield.c h_get() has an undefined behavior
+    @support.skip_if_sanitizer(ub=True)
+    def test_shorts(self):
+        b = BITS()
+        name = "M"
+        if func(byref(b), name.encode('ascii')) == 999:
+            self.skipTest("Compiler does not support signed short bitfields")
+        for i in range(256):
+            for name in "MNOPQRS":
+                b = BITS()
+                setattr(b, name, i)
+                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
+
+signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
+unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
+int_types = unsigned_int_types + signed_int_types
+
+class BitFieldTest(unittest.TestCase):
+
+    def test_longlong(self):
+        class X(Structure):
+            _fields_ = [("a", c_longlong, 1),
+                        ("b", c_longlong, 62),
+                        ("c", c_longlong, 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_longlong))
+        x = X()
+        x.a, x.b, x.c = -1, 7, -1
+        self.assertEqual((x.a, x.b, x.c), (-1, 7, -1))
+
+    def test_ulonglong(self):
+        class X(Structure):
+            _fields_ = [("a", c_ulonglong, 1),
+                        ("b", c_ulonglong, 62),
+                        ("c", c_ulonglong, 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_longlong))
+        x = X()
+        self.assertEqual((x.a, x.b, x.c), (0, 0, 0))
+        x.a, x.b, x.c = 7, 7, 7
+        self.assertEqual((x.a, x.b, x.c), (1, 7, 1))
+
+    def test_signed(self):
+        for c_typ in signed_int_types:
+            class X(Structure):
+                _fields_ = [("dummy", c_typ),
+                            ("a", c_typ, 3),
+                            ("b", c_typ, 3),
+                            ("c", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ)*2)
+
+            x = X()
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
+            x.a = -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0))
+            x.a, x.b = 0, -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0))
+
+
+    def test_unsigned(self):
+        for c_typ in unsigned_int_types:
+            class X(Structure):
+                _fields_ = [("a", c_typ, 3),
+                            ("b", c_typ, 3),
+                            ("c", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            x = X()
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
+            x.a = -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0))
+            x.a, x.b = 0, -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
+
+
+    def fail_fields(self, *fields):
+        return self.get_except(type(Structure), "X", (),
+                               {"_fields_": fields})
+
+    def test_nonint_types(self):
+        # bit fields are not allowed on non-integer types.
+        result = self.fail_fields(("a", c_char_p, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p'))
+
+        result = self.fail_fields(("a", c_void_p, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p'))
+
+        if c_int != c_long:
+            result = self.fail_fields(("a", POINTER(c_int), 1))
+            self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int'))
+
+        result = self.fail_fields(("a", c_char, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
+
+        class Dummy(Structure):
+            _fields_ = []
+
+        result = self.fail_fields(("a", Dummy, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
+
+    @need_symbol('c_wchar')
+    def test_c_wchar(self):
+        result = self.fail_fields(("a", c_wchar, 1))
+        self.assertEqual(result,
+                (TypeError, 'bit fields not allowed for type c_wchar'))
+
+    def test_single_bitfield_size(self):
+        for c_typ in int_types:
+            result = self.fail_fields(("a", c_typ, -1))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+            result = self.fail_fields(("a", c_typ, 0))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+            class X(Structure):
+                _fields_ = [("a", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            class X(Structure):
+                _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+    def test_multi_bitfields_size(self):
+        class X(Structure):
+            _fields_ = [("a", c_short, 1),
+                        ("b", c_short, 14),
+                        ("c", c_short, 1)]
+        self.assertEqual(sizeof(X), sizeof(c_short))
+
+        class X(Structure):
+            _fields_ = [("a", c_short, 1),
+                        ("a1", c_short),
+                        ("b", c_short, 14),
+                        ("c", c_short, 1)]
+        self.assertEqual(sizeof(X), sizeof(c_short)*3)
+        self.assertEqual(X.a.offset, 0)
+        self.assertEqual(X.a1.offset, sizeof(c_short))
+        self.assertEqual(X.b.offset, sizeof(c_short)*2)
+        self.assertEqual(X.c.offset, sizeof(c_short)*2)
+
+        class X(Structure):
+            _fields_ = [("a", c_short, 3),
+                        ("b", c_short, 14),
+                        ("c", c_short, 14)]
+        self.assertEqual(sizeof(X), sizeof(c_short)*3)
+        self.assertEqual(X.a.offset, sizeof(c_short)*0)
+        self.assertEqual(X.b.offset, sizeof(c_short)*1)
+        self.assertEqual(X.c.offset, sizeof(c_short)*2)
+
+
+    def get_except(self, func, *args, **kw):
+        try:
+            func(*args, **kw)
+        except Exception as detail:
+            return detail.__class__, str(detail)
+
+    def test_mixed_1(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_int, 4)]
+        if os.name == "nt":
+            self.assertEqual(sizeof(X), sizeof(c_int)*2)
+        else:
+            self.assertEqual(sizeof(X), sizeof(c_int))
+
+    def test_mixed_2(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_int, 32)]
+        self.assertEqual(sizeof(X), alignment(c_int)+sizeof(c_int))
+
+    def test_mixed_3(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_ubyte, 4)]
+        self.assertEqual(sizeof(X), sizeof(c_byte))
+
+    def test_mixed_4(self):
+        class X(Structure):
+            _fields_ = [("a", c_short, 4),
+                        ("b", c_short, 4),
+                        ("c", c_int, 24),
+                        ("d", c_short, 4),
+                        ("e", c_short, 4),
+                        ("f", c_int, 24)]
+        # MSVC does NOT combine c_short and c_int into one field, GCC
+        # does (unless GCC is run with '-mms-bitfields' which
+        # produces code compatible with MSVC).
+        if os.name == "nt":
+            self.assertEqual(sizeof(X), sizeof(c_int) * 4)
+        else:
+            self.assertEqual(sizeof(X), sizeof(c_int) * 2)
+
+    def test_anon_bitfields(self):
+        # anonymous bit-fields gave a strange error message
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_ubyte, 4)]
+        class Y(Structure):
+            _anonymous_ = ["_"]
+            _fields_ = [("_", X)]
+
+    @need_symbol('c_uint32')
+    def test_uint32(self):
+        class X(Structure):
+            _fields_ = [("a", c_uint32, 32)]
+        x = X()
+        x.a = 10
+        self.assertEqual(x.a, 10)
+        x.a = 0xFDCBA987
+        self.assertEqual(x.a, 0xFDCBA987)
+
+    @need_symbol('c_uint64')
+    def test_uint64(self):
+        class X(Structure):
+            _fields_ = [("a", c_uint64, 64)]
+        x = X()
+        x.a = 10
+        self.assertEqual(x.a, 10)
+        x.a = 0xFEDCBA9876543211
+        self.assertEqual(x.a, 0xFEDCBA9876543211)
+
+    @need_symbol('c_uint32')
+    def test_uint32_swap_little_endian(self):
+        # Issue #23319
+        class Little(LittleEndianStructure):
+            _fields_ = [("a", c_uint32, 24),
+                        ("b", c_uint32, 4),
+                        ("c", c_uint32, 4)]
+        b = bytearray(4)
+        x = Little.from_buffer(b)
+        x.a = 0xabcdef
+        x.b = 1
+        x.c = 2
+        self.assertEqual(b, b'\xef\xcd\xab\x21')
+
+    @need_symbol('c_uint32')
+    def test_uint32_swap_big_endian(self):
+        # Issue #23319
+        class Big(BigEndianStructure):
+            _fields_ = [("a", c_uint32, 24),
+                        ("b", c_uint32, 4),
+                        ("c", c_uint32, 4)]
+        b = bytearray(4)
+        x = Big.from_buffer(b)
+        x.a = 0xabcdef
+        x.b = 1
+        x.c = 2
+        self.assertEqual(b, b'\xab\xcd\xef\x12')
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_buffers.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_buffers.py
new file mode 100644
index 0000000..15782be
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_buffers.py
@@ -0,0 +1,73 @@
+from ctypes import *
+from ctypes.test import need_symbol
+import unittest
+
+class StringBufferTestCase(unittest.TestCase):
+
+    def test_buffer(self):
+        b = create_string_buffer(32)
+        self.assertEqual(len(b), 32)
+        self.assertEqual(sizeof(b), 32 * sizeof(c_char))
+        self.assertIs(type(b[0]), bytes)
+
+        b = create_string_buffer(b"abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_char))
+        self.assertIs(type(b[0]), bytes)
+        self.assertEqual(b[0], b"a")
+        self.assertEqual(b[:], b"abc\0")
+        self.assertEqual(b[::], b"abc\0")
+        self.assertEqual(b[::-1], b"\0cba")
+        self.assertEqual(b[::2], b"ac")
+        self.assertEqual(b[::5], b"a")
+
+        self.assertRaises(TypeError, create_string_buffer, "abc")
+
+    def test_buffer_interface(self):
+        self.assertEqual(len(bytearray(create_string_buffer(0))), 0)
+        self.assertEqual(len(bytearray(create_string_buffer(1))), 1)
+
+    @need_symbol('c_wchar')
+    def test_unicode_buffer(self):
+        b = create_unicode_buffer(32)
+        self.assertEqual(len(b), 32)
+        self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+
+        b = create_unicode_buffer("abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+        self.assertEqual(b[0], "a")
+        self.assertEqual(b[:], "abc\0")
+        self.assertEqual(b[::], "abc\0")
+        self.assertEqual(b[::-1], "\0cba")
+        self.assertEqual(b[::2], "ac")
+        self.assertEqual(b[::5], "a")
+
+        self.assertRaises(TypeError, create_unicode_buffer, b"abc")
+
+    @need_symbol('c_wchar')
+    def test_unicode_conversion(self):
+        b = create_unicode_buffer("abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+        self.assertEqual(b[0], "a")
+        self.assertEqual(b[:], "abc\0")
+        self.assertEqual(b[::], "abc\0")
+        self.assertEqual(b[::-1], "\0cba")
+        self.assertEqual(b[::2], "ac")
+        self.assertEqual(b[::5], "a")
+
+    @need_symbol('c_wchar')
+    def test_create_unicode_buffer_non_bmp(self):
+        expected = 5 if sizeof(c_wchar) == 2 else 3
+        for s in '\U00010000\U00100000', '\U00010000\U0010ffff':
+            b = create_unicode_buffer(s)
+            self.assertEqual(len(b), expected)
+            self.assertEqual(b[-1], '\0')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bytes.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bytes.py
new file mode 100644
index 0000000..092ec5a
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_bytes.py
@@ -0,0 +1,66 @@
+"""Test where byte objects are accepted"""
+import unittest
+import sys
+from ctypes import *
+
+class BytesTest(unittest.TestCase):
+    def test_c_char(self):
+        x = c_char(b"x")
+        self.assertRaises(TypeError, c_char, "x")
+        x.value = b"y"
+        with self.assertRaises(TypeError):
+            x.value = "y"
+        c_char.from_param(b"x")
+        self.assertRaises(TypeError, c_char.from_param, "x")
+        self.assertIn('xbd', repr(c_char.from_param(b"\xbd")))
+        (c_char * 3)(b"a", b"b", b"c")
+        self.assertRaises(TypeError, c_char * 3, "a", "b", "c")
+
+    def test_c_wchar(self):
+        x = c_wchar("x")
+        self.assertRaises(TypeError, c_wchar, b"x")
+        x.value = "y"
+        with self.assertRaises(TypeError):
+            x.value = b"y"
+        c_wchar.from_param("x")
+        self.assertRaises(TypeError, c_wchar.from_param, b"x")
+        (c_wchar * 3)("a", "b", "c")
+        self.assertRaises(TypeError, c_wchar * 3, b"a", b"b", b"c")
+
+    def test_c_char_p(self):
+        c_char_p(b"foo bar")
+        self.assertRaises(TypeError, c_char_p, "foo bar")
+
+    def test_c_wchar_p(self):
+        c_wchar_p("foo bar")
+        self.assertRaises(TypeError, c_wchar_p, b"foo bar")
+
+    def test_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_char * 3)]
+
+        x = X(b"abc")
+        self.assertRaises(TypeError, X, "abc")
+        self.assertEqual(x.a, b"abc")
+        self.assertEqual(type(x.a), bytes)
+
+    def test_struct_W(self):
+        class X(Structure):
+            _fields_ = [("a", c_wchar * 3)]
+
+        x = X("abc")
+        self.assertRaises(TypeError, X, b"abc")
+        self.assertEqual(x.a, "abc")
+        self.assertEqual(type(x.a), str)
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_BSTR(self):
+        from _ctypes import _SimpleCData
+        class BSTR(_SimpleCData):
+            _type_ = "X"
+
+        BSTR("abc")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_byteswap.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_byteswap.py
new file mode 100644
index 0000000..caefb77
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_byteswap.py
@@ -0,0 +1,356 @@
+import sys, unittest, struct, math, ctypes
+from binascii import hexlify
+
+from ctypes import *
+
+def bin(s):
+    return hexlify(memoryview(s)).decode().upper()
+
+# Each *simple* type that supports different byte orders has an
+# __ctype_be__ attribute that specifies the same type in BIG ENDIAN
+# byte order, and a __ctype_le__ attribute that is the same type in
+# LITTLE ENDIAN byte order.
+#
+# For Structures and Unions, these types are created on demand.
+
+class Test(unittest.TestCase):
+    def test_slots(self):
+        class BigPoint(BigEndianStructure):
+            __slots__ = ()
+            _fields_ = [("x", c_int), ("y", c_int)]
+
+        class LowPoint(LittleEndianStructure):
+            __slots__ = ()
+            _fields_ = [("x", c_int), ("y", c_int)]
+
+        big = BigPoint()
+        little = LowPoint()
+        big.x = 4
+        big.y = 2
+        little.x = 2
+        little.y = 4
+        with self.assertRaises(AttributeError):
+            big.z = 42
+        with self.assertRaises(AttributeError):
+            little.z = 24
+
+    def test_endian_short(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_short.__ctype_le__, c_short)
+            self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short)
+        else:
+            self.assertIs(c_short.__ctype_be__, c_short)
+            self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short)
+        s = c_short.__ctype_be__(0x1234)
+        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
+        self.assertEqual(bin(s), "1234")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_short.__ctype_le__(0x1234)
+        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
+        self.assertEqual(bin(s), "3412")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_ushort.__ctype_be__(0x1234)
+        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
+        self.assertEqual(bin(s), "1234")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_ushort.__ctype_le__(0x1234)
+        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
+        self.assertEqual(bin(s), "3412")
+        self.assertEqual(s.value, 0x1234)
+
+    def test_endian_int(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_int.__ctype_le__, c_int)
+            self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int)
+        else:
+            self.assertIs(c_int.__ctype_be__, c_int)
+            self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int)
+
+        s = c_int.__ctype_be__(0x12345678)
+        self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
+        self.assertEqual(bin(s), "12345678")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_int.__ctype_le__(0x12345678)
+        self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
+        self.assertEqual(bin(s), "78563412")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_uint.__ctype_be__(0x12345678)
+        self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
+        self.assertEqual(bin(s), "12345678")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_uint.__ctype_le__(0x12345678)
+        self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
+        self.assertEqual(bin(s), "78563412")
+        self.assertEqual(s.value, 0x12345678)
+
+    def test_endian_longlong(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_longlong.__ctype_le__, c_longlong)
+            self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong)
+        else:
+            self.assertIs(c_longlong.__ctype_be__, c_longlong)
+            self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong)
+
+        s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
+        self.assertEqual(bin(s), "1234567890ABCDEF")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
+        self.assertEqual(bin(s), "EFCDAB9078563412")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
+        self.assertEqual(bin(s), "1234567890ABCDEF")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
+        self.assertEqual(bin(s), "EFCDAB9078563412")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+    def test_endian_float(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_float.__ctype_le__, c_float)
+            self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float)
+        else:
+            self.assertIs(c_float.__ctype_be__, c_float)
+            self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float)
+        s = c_float(math.pi)
+        self.assertEqual(bin(struct.pack("f", math.pi)), bin(s))
+        # Hm, what's the precision of a float compared to a double?
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        s = c_float.__ctype_le__(math.pi)
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
+        s = c_float.__ctype_be__(math.pi)
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
+
+    def test_endian_double(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_double.__ctype_le__, c_double)
+            self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double)
+        else:
+            self.assertIs(c_double.__ctype_be__, c_double)
+            self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double)
+        s = c_double(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
+        s = c_double.__ctype_le__(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
+        s = c_double.__ctype_be__(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
+
+    def test_endian_other(self):
+        self.assertIs(c_byte.__ctype_le__, c_byte)
+        self.assertIs(c_byte.__ctype_be__, c_byte)
+
+        self.assertIs(c_ubyte.__ctype_le__, c_ubyte)
+        self.assertIs(c_ubyte.__ctype_be__, c_ubyte)
+
+        self.assertIs(c_char.__ctype_le__, c_char)
+        self.assertIs(c_char.__ctype_be__, c_char)
+
+    def test_struct_fields_unsupported_byte_order(self):
+
+        fields = [
+            ("a", c_ubyte),
+            ("b", c_byte),
+            ("c", c_short),
+            ("d", c_ushort),
+            ("e", c_int),
+            ("f", c_uint),
+            ("g", c_long),
+            ("h", c_ulong),
+            ("i", c_longlong),
+            ("k", c_ulonglong),
+            ("l", c_float),
+            ("m", c_double),
+            ("n", c_char),
+            ("b1", c_byte, 3),
+            ("b2", c_byte, 3),
+            ("b3", c_byte, 2),
+            ("a", c_int * 3 * 3 * 3)
+        ]
+
+        # these fields do not support different byte order:
+        for typ in c_wchar, c_void_p, POINTER(c_int):
+            with self.assertRaises(TypeError):
+                class T(BigEndianStructure if sys.byteorder == "little" else LittleEndianStructure):
+                    _fields_ = fields + [("x", typ)]
+
+
+    def test_struct_struct(self):
+        # nested structures with different byteorders
+
+        # create nested structures with given byteorders and set memory to data
+
+        for nested, data in (
+            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
+            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
+        ):
+            for parent in (
+                BigEndianStructure,
+                LittleEndianStructure,
+                Structure,
+            ):
+                class NestedStructure(nested):
+                    _fields_ = [("x", c_uint32),
+                                ("y", c_uint32)]
+
+                class TestStructure(parent):
+                    _fields_ = [("point", NestedStructure)]
+
+                self.assertEqual(len(data), sizeof(TestStructure))
+                ptr = POINTER(TestStructure)
+                s = cast(data, ptr)[0]
+                del ctypes._pointer_type_cache[TestStructure]
+                self.assertEqual(s.point.x, 1)
+                self.assertEqual(s.point.y, 2)
+
+    def test_struct_field_alignment(self):
+        # standard packing in struct uses no alignment.
+        # So, we have to align using pad bytes.
+        #
+        # Unaligned accesses will crash Python (on those platforms that
+        # don't allow it, like sparc solaris).
+        if sys.byteorder == "little":
+            base = BigEndianStructure
+            fmt = ">bxhid"
+        else:
+            base = LittleEndianStructure
+            fmt = "<bxhid"
+
+        class S(base):
+            _fields_ = [("b", c_byte),
+                        ("h", c_short),
+                        ("i", c_int),
+                        ("d", c_double)]
+
+        s1 = S(0x12, 0x1234, 0x12345678, 3.14)
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_unaligned_nonnative_struct_fields(self):
+        if sys.byteorder == "little":
+            base = BigEndianStructure
+            fmt = ">b h xi xd"
+        else:
+            base = LittleEndianStructure
+            fmt = "<b h xi xd"
+
+        class S(base):
+            _pack_ = 1
+            _fields_ = [("b", c_byte),
+                        ("h", c_short),
+
+                        ("_1", c_byte),
+                        ("i", c_int),
+
+                        ("_2", c_byte),
+                        ("d", c_double)]
+
+        s1 = S()
+        s1.b = 0x12
+        s1.h = 0x1234
+        s1.i = 0x12345678
+        s1.d = 3.14
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_unaligned_native_struct_fields(self):
+        if sys.byteorder == "little":
+            fmt = "<b h xi xd"
+        else:
+            base = LittleEndianStructure
+            fmt = ">b h xi xd"
+
+        class S(Structure):
+            _pack_ = 1
+            _fields_ = [("b", c_byte),
+
+                        ("h", c_short),
+
+                        ("_1", c_byte),
+                        ("i", c_int),
+
+                        ("_2", c_byte),
+                        ("d", c_double)]
+
+        s1 = S()
+        s1.b = 0x12
+        s1.h = 0x1234
+        s1.i = 0x12345678
+        s1.d = 3.14
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_union_fields_unsupported_byte_order(self):
+
+        fields = [
+            ("a", c_ubyte),
+            ("b", c_byte),
+            ("c", c_short),
+            ("d", c_ushort),
+            ("e", c_int),
+            ("f", c_uint),
+            ("g", c_long),
+            ("h", c_ulong),
+            ("i", c_longlong),
+            ("k", c_ulonglong),
+            ("l", c_float),
+            ("m", c_double),
+            ("n", c_char),
+            ("b1", c_byte, 3),
+            ("b2", c_byte, 3),
+            ("b3", c_byte, 2),
+            ("a", c_int * 3 * 3 * 3)
+        ]
+
+        # these fields do not support different byte order:
+        for typ in c_wchar, c_void_p, POINTER(c_int):
+            with self.assertRaises(TypeError):
+                class T(BigEndianUnion if sys.byteorder == "little" else LittleEndianUnion):
+                    _fields_ = fields + [("x", typ)]
+
+    def test_union_struct(self):
+        # nested structures in unions with different byteorders
+
+        # create nested structures in unions with given byteorders and set memory to data
+
+        for nested, data in (
+            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
+            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
+        ):
+            for parent in (
+                BigEndianUnion,
+                LittleEndianUnion,
+                Union,
+            ):
+                class NestedStructure(nested):
+                    _fields_ = [("x", c_uint32),
+                                ("y", c_uint32)]
+
+                class TestUnion(parent):
+                    _fields_ = [("point", NestedStructure)]
+
+                self.assertEqual(len(data), sizeof(TestUnion))
+                ptr = POINTER(TestUnion)
+                s = cast(data, ptr)[0]
+                del ctypes._pointer_type_cache[TestUnion]
+                self.assertEqual(s.point.x, 1)
+                self.assertEqual(s.point.y, 2)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_callbacks.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_callbacks.py
new file mode 100644
index 0000000..5c514db
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_callbacks.py
@@ -0,0 +1,325 @@
+import functools
+import unittest
+from test import support
+
+from ctypes import *
+from ctypes.test import need_symbol
+from _ctypes import CTYPES_MAX_ARGCOUNT
+import _ctypes_test
+
+class Callbacks(unittest.TestCase):
+    functype = CFUNCTYPE
+
+##    def tearDown(self):
+##        import gc
+##        gc.collect()
+
+    def callback(self, *args):
+        self.got_args = args
+        return args[-1]
+
+    def check_type(self, typ, arg):
+        PROTO = self.functype.__func__(typ, typ)
+        result = PROTO(self.callback)(arg)
+        if typ == c_float:
+            self.assertAlmostEqual(result, arg, places=5)
+        else:
+            self.assertEqual(self.got_args, (arg,))
+            self.assertEqual(result, arg)
+
+        PROTO = self.functype.__func__(typ, c_byte, typ)
+        result = PROTO(self.callback)(-3, arg)
+        if typ == c_float:
+            self.assertAlmostEqual(result, arg, places=5)
+        else:
+            self.assertEqual(self.got_args, (-3, arg))
+            self.assertEqual(result, arg)
+
+    ################
+
+    def test_byte(self):
+        self.check_type(c_byte, 42)
+        self.check_type(c_byte, -42)
+
+    def test_ubyte(self):
+        self.check_type(c_ubyte, 42)
+
+    def test_short(self):
+        self.check_type(c_short, 42)
+        self.check_type(c_short, -42)
+
+    def test_ushort(self):
+        self.check_type(c_ushort, 42)
+
+    def test_int(self):
+        self.check_type(c_int, 42)
+        self.check_type(c_int, -42)
+
+    def test_uint(self):
+        self.check_type(c_uint, 42)
+
+    def test_long(self):
+        self.check_type(c_long, 42)
+        self.check_type(c_long, -42)
+
+    def test_ulong(self):
+        self.check_type(c_ulong, 42)
+
+    @need_symbol('c_longlong')
+    def test_longlong(self):
+        self.check_type(c_longlong, 42)
+        self.check_type(c_longlong, -42)
+
+    @need_symbol('c_ulonglong')
+    def test_ulonglong(self):
+        self.check_type(c_ulonglong, 42)
+
+    def test_float(self):
+        # only almost equal: double -> float -> double
+        import math
+        self.check_type(c_float, math.e)
+        self.check_type(c_float, -math.e)
+
+    def test_double(self):
+        self.check_type(c_double, 3.14)
+        self.check_type(c_double, -3.14)
+
+    @need_symbol('c_longdouble')
+    def test_longdouble(self):
+        self.check_type(c_longdouble, 3.14)
+        self.check_type(c_longdouble, -3.14)
+
+    def test_char(self):
+        self.check_type(c_char, b"x")
+        self.check_type(c_char, b"a")
+
+    def test_pyobject(self):
+        o = ()
+        from sys import getrefcount as grc
+        for o in (), [], object():
+            initial = grc(o)
+            # This call leaks a reference to 'o'...
+            self.check_type(py_object, o)
+            before = grc(o)
+            # ...but this call doesn't leak any more.  Where is the refcount?
+            self.check_type(py_object, o)
+            after = grc(o)
+            self.assertEqual((after, o), (before, o))
+
+    def test_unsupported_restype_1(self):
+        # Only "fundamental" result types are supported for callback
+        # functions, the type must have a non-NULL stgdict->setfunc.
+        # POINTER(c_double), for example, is not supported.
+
+        prototype = self.functype.__func__(POINTER(c_double))
+        # The type is checked when the prototype is called
+        self.assertRaises(TypeError, prototype, lambda: None)
+
+    def test_unsupported_restype_2(self):
+        prototype = self.functype.__func__(object)
+        self.assertRaises(TypeError, prototype, lambda: None)
+
+    def test_issue_7959(self):
+        proto = self.functype.__func__(None)
+
+        class X:
+            def func(self): pass
+            def __init__(self):
+                self.v = proto(self.func)
+
+        import gc
+        for i in range(32):
+            X()
+        gc.collect()
+        live = [x for x in gc.get_objects()
+                if isinstance(x, X)]
+        self.assertEqual(len(live), 0)
+
+    def test_issue12483(self):
+        import gc
+        class Nasty:
+            def __del__(self):
+                gc.collect()
+        CFUNCTYPE(None)(lambda x=Nasty(): None)
+
+
+@need_symbol('WINFUNCTYPE')
+class StdcallCallbacks(Callbacks):
+    try:
+        functype = WINFUNCTYPE
+    except NameError:
+        pass
+
+################################################################
+
+class SampleCallbacksTestCase(unittest.TestCase):
+
+    def test_integrate(self):
+        # Derived from some then non-working code, posted by David Foster
+        dll = CDLL(_ctypes_test.__file__)
+
+        # The function prototype called by 'integrate': double func(double);
+        CALLBACK = CFUNCTYPE(c_double, c_double)
+
+        # The integrate function itself, exposed from the _ctypes_test dll
+        integrate = dll.integrate
+        integrate.argtypes = (c_double, c_double, CALLBACK, c_long)
+        integrate.restype = c_double
+
+        def func(x):
+            return x**2
+
+        result = integrate(0.0, 1.0, CALLBACK(func), 10)
+        diff = abs(result - 1./3.)
+
+        self.assertLess(diff, 0.01, "%s not less than 0.01" % diff)
+
+    def test_issue_8959_a(self):
+        from ctypes.util import find_library
+        libc_path = find_library("c")
+        if not libc_path:
+            self.skipTest('could not find libc')
+        libc = CDLL(libc_path)
+
+        @CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
+        def cmp_func(a, b):
+            return a[0] - b[0]
+
+        array = (c_int * 5)(5, 1, 99, 7, 33)
+
+        libc.qsort(array, len(array), sizeof(c_int), cmp_func)
+        self.assertEqual(array[:], [1, 5, 7, 33, 99])
+
+    @need_symbol('WINFUNCTYPE')
+    def test_issue_8959_b(self):
+        from ctypes.wintypes import BOOL, HWND, LPARAM
+        global windowCount
+        windowCount = 0
+
+        @WINFUNCTYPE(BOOL, HWND, LPARAM)
+        def EnumWindowsCallbackFunc(hwnd, lParam):
+            global windowCount
+            windowCount += 1
+            return True #Allow windows to keep enumerating
+
+        windll.user32.EnumWindows(EnumWindowsCallbackFunc, 0)
+
+    def test_callback_register_int(self):
+        # Issue #8275: buggy handling of callback args under Win64
+        # NOTE: should be run on release builds as well
+        dll = CDLL(_ctypes_test.__file__)
+        CALLBACK = CFUNCTYPE(c_int, c_int, c_int, c_int, c_int, c_int)
+        # All this function does is call the callback with its args squared
+        func = dll._testfunc_cbk_reg_int
+        func.argtypes = (c_int, c_int, c_int, c_int, c_int, CALLBACK)
+        func.restype = c_int
+
+        def callback(a, b, c, d, e):
+            return a + b + c + d + e
+
+        result = func(2, 3, 4, 5, 6, CALLBACK(callback))
+        self.assertEqual(result, callback(2*2, 3*3, 4*4, 5*5, 6*6))
+
+    def test_callback_register_double(self):
+        # Issue #8275: buggy handling of callback args under Win64
+        # NOTE: should be run on release builds as well
+        dll = CDLL(_ctypes_test.__file__)
+        CALLBACK = CFUNCTYPE(c_double, c_double, c_double, c_double,
+                             c_double, c_double)
+        # All this function does is call the callback with its args squared
+        func = dll._testfunc_cbk_reg_double
+        func.argtypes = (c_double, c_double, c_double,
+                         c_double, c_double, CALLBACK)
+        func.restype = c_double
+
+        def callback(a, b, c, d, e):
+            return a + b + c + d + e
+
+        result = func(1.1, 2.2, 3.3, 4.4, 5.5, CALLBACK(callback))
+        self.assertEqual(result,
+                         callback(1.1*1.1, 2.2*2.2, 3.3*3.3, 4.4*4.4, 5.5*5.5))
+
+    def test_callback_large_struct(self):
+        class Check: pass
+
+        # This should mirror the structure in Modules/_ctypes/_ctypes_test.c
+        class X(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+
+        def callback(check, s):
+            check.first = s.first
+            check.second = s.second
+            check.third = s.third
+            # See issue #29565.
+            # The structure should be passed by value, so
+            # any changes to it should not be reflected in
+            # the value passed
+            s.first = s.second = s.third = 0x0badf00d
+
+        check = Check()
+        s = X()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        s.third = 0x0bad1dea
+
+        CALLBACK = CFUNCTYPE(None, X)
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_cbk_large_struct
+        func.argtypes = (X, CALLBACK)
+        func.restype = None
+        # the function just calls the callback with the passed structure
+        func(s, CALLBACK(functools.partial(callback, check)))
+        self.assertEqual(check.first, s.first)
+        self.assertEqual(check.second, s.second)
+        self.assertEqual(check.third, s.third)
+        self.assertEqual(check.first, 0xdeadbeef)
+        self.assertEqual(check.second, 0xcafebabe)
+        self.assertEqual(check.third, 0x0bad1dea)
+        # See issue #29565.
+        # Ensure that the original struct is unchanged.
+        self.assertEqual(s.first, check.first)
+        self.assertEqual(s.second, check.second)
+        self.assertEqual(s.third, check.third)
+
+    def test_callback_too_many_args(self):
+        def func(*args):
+            return len(args)
+
+        # valid call with nargs <= CTYPES_MAX_ARGCOUNT
+        proto = CFUNCTYPE(c_int, *(c_int,) * CTYPES_MAX_ARGCOUNT)
+        cb = proto(func)
+        args1 = (1,) * CTYPES_MAX_ARGCOUNT
+        self.assertEqual(cb(*args1), CTYPES_MAX_ARGCOUNT)
+
+        # invalid call with nargs > CTYPES_MAX_ARGCOUNT
+        args2 = (1,) * (CTYPES_MAX_ARGCOUNT + 1)
+        with self.assertRaises(ArgumentError):
+            cb(*args2)
+
+        # error when creating the type with too many arguments
+        with self.assertRaises(ArgumentError):
+            CFUNCTYPE(c_int, *(c_int,) * (CTYPES_MAX_ARGCOUNT + 1))
+
+    def test_convert_result_error(self):
+        def func():
+            return ("tuple",)
+
+        proto = CFUNCTYPE(c_int)
+        ctypes_func = proto(func)
+        with support.catch_unraisable_exception() as cm:
+            # don't test the result since it is an uninitialized value
+            result = ctypes_func()
+
+            self.assertIsInstance(cm.unraisable.exc_value, TypeError)
+            self.assertEqual(cm.unraisable.err_msg,
+                             "Exception ignored on converting result "
+                             "of ctypes callback function")
+            self.assertIs(cm.unraisable.object, func)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cast.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cast.py
new file mode 100644
index 0000000..6878f97
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cast.py
@@ -0,0 +1,99 @@
+from ctypes import *
+from ctypes.test import need_symbol
+import unittest
+import sys
+
+class Test(unittest.TestCase):
+
+    def test_array2pointer(self):
+        array = (c_int * 3)(42, 17, 2)
+
+        # casting an array to a pointer works.
+        ptr = cast(array, POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+        if 2*sizeof(c_short) == sizeof(c_int):
+            ptr = cast(array, POINTER(c_short))
+            if sys.byteorder == "little":
+                self.assertEqual([ptr[i] for i in range(6)],
+                                     [42, 0, 17, 0, 2, 0])
+            else:
+                self.assertEqual([ptr[i] for i in range(6)],
+                                     [0, 42, 0, 17, 0, 2])
+
+    def test_address2pointer(self):
+        array = (c_int * 3)(42, 17, 2)
+
+        address = addressof(array)
+        ptr = cast(c_void_p(address), POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+        ptr = cast(address, POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+    def test_p2a_objects(self):
+        array = (c_char_p * 5)()
+        self.assertEqual(array._objects, None)
+        array[0] = b"foo bar"
+        self.assertEqual(array._objects, {'0': b"foo bar"})
+
+        p = cast(array, POINTER(c_char_p))
+        # array and p share a common _objects attribute
+        self.assertIs(p._objects, array._objects)
+        self.assertEqual(array._objects, {'0': b"foo bar", id(array): array})
+        p[0] = b"spam spam"
+        self.assertEqual(p._objects, {'0': b"spam spam", id(array): array})
+        self.assertIs(array._objects, p._objects)
+        p[1] = b"foo bar"
+        self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
+        self.assertIs(array._objects, p._objects)
+
+    def test_other(self):
+        p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
+        self.assertEqual(p[:4], [1,2, 3, 4])
+        self.assertEqual(p[:4:], [1, 2, 3, 4])
+        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        c_int()
+        self.assertEqual(p[:4], [1, 2, 3, 4])
+        self.assertEqual(p[:4:], [1, 2, 3, 4])
+        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        p[2] = 96
+        self.assertEqual(p[:4], [1, 2, 96, 4])
+        self.assertEqual(p[:4:], [1, 2, 96, 4])
+        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        c_int()
+        self.assertEqual(p[:4], [1, 2, 96, 4])
+        self.assertEqual(p[:4:], [1, 2, 96, 4])
+        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+
+    def test_char_p(self):
+        # This didn't work: bad argument to internal function
+        s = c_char_p(b"hiho")
+        self.assertEqual(cast(cast(s, c_void_p), c_char_p).value,
+                             b"hiho")
+
+    @need_symbol('c_wchar_p')
+    def test_wchar_p(self):
+        s = c_wchar_p("hiho")
+        self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
+                             "hiho")
+
+    def test_bad_type_arg(self):
+        # The type argument must be a ctypes pointer type.
+        array_type = c_byte * sizeof(c_int)
+        array = array_type()
+        self.assertRaises(TypeError, cast, array, None)
+        self.assertRaises(TypeError, cast, array, array_type)
+        class Struct(Structure):
+            _fields_ = [("a", c_int)]
+        self.assertRaises(TypeError, cast, array, Struct)
+        class MyUnion(Union):
+            _fields_ = [("a", c_int)]
+        self.assertRaises(TypeError, cast, array, MyUnion)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cfuncs.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cfuncs.py
new file mode 100644
index 0000000..09b0684
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_cfuncs.py
@@ -0,0 +1,218 @@
+# A lot of failures in these tests on Mac OS X.
+# Byte order related?
+
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+
+import _ctypes_test
+
+class CFunctions(unittest.TestCase):
+    _dll = CDLL(_ctypes_test.__file__)
+
+    def S(self):
+        return c_longlong.in_dll(self._dll, "last_tf_arg_s").value
+    def U(self):
+        return c_ulonglong.in_dll(self._dll, "last_tf_arg_u").value
+
+    def test_byte(self):
+        self._dll.tf_b.restype = c_byte
+        self._dll.tf_b.argtypes = (c_byte,)
+        self.assertEqual(self._dll.tf_b(-126), -42)
+        self.assertEqual(self.S(), -126)
+
+    def test_byte_plus(self):
+        self._dll.tf_bb.restype = c_byte
+        self._dll.tf_bb.argtypes = (c_byte, c_byte)
+        self.assertEqual(self._dll.tf_bb(0, -126), -42)
+        self.assertEqual(self.S(), -126)
+
+    def test_ubyte(self):
+        self._dll.tf_B.restype = c_ubyte
+        self._dll.tf_B.argtypes = (c_ubyte,)
+        self.assertEqual(self._dll.tf_B(255), 85)
+        self.assertEqual(self.U(), 255)
+
+    def test_ubyte_plus(self):
+        self._dll.tf_bB.restype = c_ubyte
+        self._dll.tf_bB.argtypes = (c_byte, c_ubyte)
+        self.assertEqual(self._dll.tf_bB(0, 255), 85)
+        self.assertEqual(self.U(), 255)
+
+    def test_short(self):
+        self._dll.tf_h.restype = c_short
+        self._dll.tf_h.argtypes = (c_short,)
+        self.assertEqual(self._dll.tf_h(-32766), -10922)
+        self.assertEqual(self.S(), -32766)
+
+    def test_short_plus(self):
+        self._dll.tf_bh.restype = c_short
+        self._dll.tf_bh.argtypes = (c_byte, c_short)
+        self.assertEqual(self._dll.tf_bh(0, -32766), -10922)
+        self.assertEqual(self.S(), -32766)
+
+    def test_ushort(self):
+        self._dll.tf_H.restype = c_ushort
+        self._dll.tf_H.argtypes = (c_ushort,)
+        self.assertEqual(self._dll.tf_H(65535), 21845)
+        self.assertEqual(self.U(), 65535)
+
+    def test_ushort_plus(self):
+        self._dll.tf_bH.restype = c_ushort
+        self._dll.tf_bH.argtypes = (c_byte, c_ushort)
+        self.assertEqual(self._dll.tf_bH(0, 65535), 21845)
+        self.assertEqual(self.U(), 65535)
+
+    def test_int(self):
+        self._dll.tf_i.restype = c_int
+        self._dll.tf_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tf_i(-2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_int_plus(self):
+        self._dll.tf_bi.restype = c_int
+        self._dll.tf_bi.argtypes = (c_byte, c_int)
+        self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_uint(self):
+        self._dll.tf_I.restype = c_uint
+        self._dll.tf_I.argtypes = (c_uint,)
+        self.assertEqual(self._dll.tf_I(4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_uint_plus(self):
+        self._dll.tf_bI.restype = c_uint
+        self._dll.tf_bI.argtypes = (c_byte, c_uint)
+        self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_long(self):
+        self._dll.tf_l.restype = c_long
+        self._dll.tf_l.argtypes = (c_long,)
+        self.assertEqual(self._dll.tf_l(-2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_long_plus(self):
+        self._dll.tf_bl.restype = c_long
+        self._dll.tf_bl.argtypes = (c_byte, c_long)
+        self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_ulong(self):
+        self._dll.tf_L.restype = c_ulong
+        self._dll.tf_L.argtypes = (c_ulong,)
+        self.assertEqual(self._dll.tf_L(4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_ulong_plus(self):
+        self._dll.tf_bL.restype = c_ulong
+        self._dll.tf_bL.argtypes = (c_char, c_ulong)
+        self.assertEqual(self._dll.tf_bL(b' ', 4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    @need_symbol('c_longlong')
+    def test_longlong(self):
+        self._dll.tf_q.restype = c_longlong
+        self._dll.tf_q.argtypes = (c_longlong, )
+        self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
+        self.assertEqual(self.S(), -9223372036854775806)
+
+    @need_symbol('c_longlong')
+    def test_longlong_plus(self):
+        self._dll.tf_bq.restype = c_longlong
+        self._dll.tf_bq.argtypes = (c_byte, c_longlong)
+        self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
+        self.assertEqual(self.S(), -9223372036854775806)
+
+    @need_symbol('c_ulonglong')
+    def test_ulonglong(self):
+        self._dll.tf_Q.restype = c_ulonglong
+        self._dll.tf_Q.argtypes = (c_ulonglong, )
+        self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
+        self.assertEqual(self.U(), 18446744073709551615)
+
+    @need_symbol('c_ulonglong')
+    def test_ulonglong_plus(self):
+        self._dll.tf_bQ.restype = c_ulonglong
+        self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
+        self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
+        self.assertEqual(self.U(), 18446744073709551615)
+
+    def test_float(self):
+        self._dll.tf_f.restype = c_float
+        self._dll.tf_f.argtypes = (c_float,)
+        self.assertEqual(self._dll.tf_f(-42.), -14.)
+        self.assertEqual(self.S(), -42)
+
+    def test_float_plus(self):
+        self._dll.tf_bf.restype = c_float
+        self._dll.tf_bf.argtypes = (c_byte, c_float)
+        self.assertEqual(self._dll.tf_bf(0, -42.), -14.)
+        self.assertEqual(self.S(), -42)
+
+    def test_double(self):
+        self._dll.tf_d.restype = c_double
+        self._dll.tf_d.argtypes = (c_double,)
+        self.assertEqual(self._dll.tf_d(42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_double_plus(self):
+        self._dll.tf_bd.restype = c_double
+        self._dll.tf_bd.argtypes = (c_byte, c_double)
+        self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    @need_symbol('c_longdouble')
+    def test_longdouble(self):
+        self._dll.tf_D.restype = c_longdouble
+        self._dll.tf_D.argtypes = (c_longdouble,)
+        self.assertEqual(self._dll.tf_D(42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    @need_symbol('c_longdouble')
+    def test_longdouble_plus(self):
+        self._dll.tf_bD.restype = c_longdouble
+        self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
+        self.assertEqual(self._dll.tf_bD(0, 42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_callwithresult(self):
+        def process_result(result):
+            return result * 2
+        self._dll.tf_i.restype = process_result
+        self._dll.tf_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tf_i(42), 28)
+        self.assertEqual(self.S(), 42)
+        self.assertEqual(self._dll.tf_i(-42), -28)
+        self.assertEqual(self.S(), -42)
+
+    def test_void(self):
+        self._dll.tv_i.restype = None
+        self._dll.tv_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tv_i(42), None)
+        self.assertEqual(self.S(), 42)
+        self.assertEqual(self._dll.tv_i(-42), None)
+        self.assertEqual(self.S(), -42)
+
+# The following repeats the above tests with stdcall functions (where
+# they are available)
+try:
+    WinDLL
+except NameError:
+    def stdcall_dll(*_): pass
+else:
+    class stdcall_dll(WinDLL):
+        def __getattr__(self, name):
+            if name[:2] == '__' and name[-2:] == '__':
+                raise AttributeError(name)
+            func = self._FuncPtr(("s_" + name, self))
+            setattr(self, name, func)
+            return func
+
+@need_symbol('WinDLL')
+class stdcallCFunctions(CFunctions):
+    _dll = stdcall_dll(_ctypes_test.__file__)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_checkretval.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_checkretval.py
new file mode 100644
index 0000000..e9567dc
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_checkretval.py
@@ -0,0 +1,36 @@
+import unittest
+
+from ctypes import *
+from ctypes.test import need_symbol
+
+class CHECKED(c_int):
+    def _check_retval_(value):
+        # Receives a CHECKED instance.
+        return str(value.value)
+    _check_retval_ = staticmethod(_check_retval_)
+
+class Test(unittest.TestCase):
+
+    def test_checkretval(self):
+
+        import _ctypes_test
+        dll = CDLL(_ctypes_test.__file__)
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = CHECKED
+        self.assertEqual("42", dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = None
+        self.assertEqual(None, dll._testfunc_p_p(42))
+
+        del dll._testfunc_p_p.restype
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+    @need_symbol('oledll')
+    def test_oledll(self):
+        self.assertRaises(OSError,
+                              oledll.oleaut32.CreateTypeLib2,
+                              0, None, None)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_delattr.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_delattr.py
new file mode 100644
index 0000000..0f4d586
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_delattr.py
@@ -0,0 +1,21 @@
+import unittest
+from ctypes import *
+
+class X(Structure):
+    _fields_ = [("foo", c_int)]
+
+class TestCase(unittest.TestCase):
+    def test_simple(self):
+        self.assertRaises(TypeError,
+                          delattr, c_int(42), "value")
+
+    def test_chararray(self):
+        self.assertRaises(TypeError,
+                          delattr, (c_char * 5)(), "value")
+
+    def test_struct(self):
+        self.assertRaises(TypeError,
+                          delattr, X(), "foo")
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_errno.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_errno.py
new file mode 100644
index 0000000..3685164
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_errno.py
@@ -0,0 +1,76 @@
+import unittest, os, errno
+import threading
+
+from ctypes import *
+from ctypes.util import find_library
+
+class Test(unittest.TestCase):
+    def test_open(self):
+        libc_name = find_library("c")
+        if libc_name is None:
+            raise unittest.SkipTest("Unable to find C library")
+        libc = CDLL(libc_name, use_errno=True)
+        if os.name == "nt":
+            libc_open = libc._open
+        else:
+            libc_open = libc.open
+
+        libc_open.argtypes = c_char_p, c_int
+
+        self.assertEqual(libc_open(b"", 0), -1)
+        self.assertEqual(get_errno(), errno.ENOENT)
+
+        self.assertEqual(set_errno(32), errno.ENOENT)
+        self.assertEqual(get_errno(), 32)
+
+        def _worker():
+            set_errno(0)
+
+            libc = CDLL(libc_name, use_errno=False)
+            if os.name == "nt":
+                libc_open = libc._open
+            else:
+                libc_open = libc.open
+            libc_open.argtypes = c_char_p, c_int
+            self.assertEqual(libc_open(b"", 0), -1)
+            self.assertEqual(get_errno(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(get_errno(), 32)
+        set_errno(0)
+
+    @unittest.skipUnless(os.name == "nt", 'Test specific to Windows')
+    def test_GetLastError(self):
+        dll = WinDLL("kernel32", use_last_error=True)
+        GetModuleHandle = dll.GetModuleHandleA
+        GetModuleHandle.argtypes = [c_wchar_p]
+
+        self.assertEqual(0, GetModuleHandle("foo"))
+        self.assertEqual(get_last_error(), 126)
+
+        self.assertEqual(set_last_error(32), 126)
+        self.assertEqual(get_last_error(), 32)
+
+        def _worker():
+            set_last_error(0)
+
+            dll = WinDLL("kernel32", use_last_error=False)
+            GetModuleHandle = dll.GetModuleHandleW
+            GetModuleHandle.argtypes = [c_wchar_p]
+            GetModuleHandle("bar")
+
+            self.assertEqual(get_last_error(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(get_last_error(), 32)
+
+        set_last_error(0)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_find.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_find.py
new file mode 100644
index 0000000..1ff9d01
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_find.py
@@ -0,0 +1,127 @@
+import unittest
+import unittest.mock
+import os.path
+import sys
+import test.support
+from test.support import os_helper
+from ctypes import *
+from ctypes.util import find_library
+
+# On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.
+class Test_OpenGL_libs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        lib_gl = lib_glu = lib_gle = None
+        if sys.platform == "win32":
+            lib_gl = find_library("OpenGL32")
+            lib_glu = find_library("Glu32")
+        elif sys.platform == "darwin":
+            lib_gl = lib_glu = find_library("OpenGL")
+        else:
+            lib_gl = find_library("GL")
+            lib_glu = find_library("GLU")
+            lib_gle = find_library("gle")
+
+        ## print, for debugging
+        if test.support.verbose:
+            print("OpenGL libraries:")
+            for item in (("GL", lib_gl),
+                         ("GLU", lib_glu),
+                         ("gle", lib_gle)):
+                print("\t", item)
+
+        cls.gl = cls.glu = cls.gle = None
+        if lib_gl:
+            try:
+                cls.gl = CDLL(lib_gl, mode=RTLD_GLOBAL)
+            except OSError:
+                pass
+        if lib_glu:
+            try:
+                cls.glu = CDLL(lib_glu, RTLD_GLOBAL)
+            except OSError:
+                pass
+        if lib_gle:
+            try:
+                cls.gle = CDLL(lib_gle)
+            except OSError:
+                pass
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.gl = cls.glu = cls.gle = None
+
+    def test_gl(self):
+        if self.gl is None:
+            self.skipTest('lib_gl not available')
+        self.gl.glClearIndex
+
+    def test_glu(self):
+        if self.glu is None:
+            self.skipTest('lib_glu not available')
+        self.glu.gluBeginCurve
+
+    def test_gle(self):
+        if self.gle is None:
+            self.skipTest('lib_gle not available')
+        self.gle.gleGetJoinStyle
+
+    def test_shell_injection(self):
+        result = find_library('; echo Hello shell > ' + os_helper.TESTFN)
+        self.assertFalse(os.path.lexists(os_helper.TESTFN))
+        self.assertIsNone(result)
+
+
+@unittest.skipUnless(sys.platform.startswith('linux'),
+                     'Test only valid for Linux')
+class FindLibraryLinux(unittest.TestCase):
+    def test_find_on_libpath(self):
+        import subprocess
+        import tempfile
+
+        try:
+            p = subprocess.Popen(['gcc', '--version'], stdout=subprocess.PIPE,
+                                 stderr=subprocess.DEVNULL)
+            out, _ = p.communicate()
+        except OSError:
+            raise unittest.SkipTest('gcc, needed for test, not available')
+        with tempfile.TemporaryDirectory() as d:
+            # create an empty temporary file
+            srcname = os.path.join(d, 'dummy.c')
+            libname = 'py_ctypes_test_dummy'
+            dstname = os.path.join(d, 'lib%s.so' % libname)
+            with open(srcname, 'wb') as f:
+                pass
+            self.assertTrue(os.path.exists(srcname))
+            # compile the file to a shared library
+            cmd = ['gcc', '-o', dstname, '--shared',
+                   '-Wl,-soname,lib%s.so' % libname, srcname]
+            out = subprocess.check_output(cmd)
+            self.assertTrue(os.path.exists(dstname))
+            # now check that the .so can't be found (since not in
+            # LD_LIBRARY_PATH)
+            self.assertIsNone(find_library(libname))
+            # now add the location to LD_LIBRARY_PATH
+            with os_helper.EnvironmentVarGuard() as env:
+                KEY = 'LD_LIBRARY_PATH'
+                if KEY not in env:
+                    v = d
+                else:
+                    v = '%s:%s' % (env[KEY], d)
+                env.set(KEY, v)
+                # now check that the .so can be found (since in
+                # LD_LIBRARY_PATH)
+                self.assertEqual(find_library(libname), 'lib%s.so' % libname)
+
+    def test_find_library_with_gcc(self):
+        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None):
+            self.assertNotEqual(find_library('c'), None)
+
+    def test_find_library_with_ld(self):
+        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None), \
+             unittest.mock.patch("ctypes.util._findLib_gcc", lambda *args: None):
+            self.assertNotEqual(find_library('c'), None)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_frombuffer.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_frombuffer.py
new file mode 100644
index 0000000..55c2443
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_frombuffer.py
@@ -0,0 +1,141 @@
+from ctypes import *
+import array
+import gc
+import unittest
+
+class X(Structure):
+    _fields_ = [("c_int", c_int)]
+    init_called = False
+    def __init__(self):
+        self._init_called = True
+
+class Test(unittest.TestCase):
+    def test_from_buffer(self):
+        a = array.array("i", range(16))
+        x = (c_int * 16).from_buffer(a)
+
+        y = X.from_buffer(a)
+        self.assertEqual(y.c_int, a[0])
+        self.assertFalse(y.init_called)
+
+        self.assertEqual(x[:], a.tolist())
+
+        a[0], a[-1] = 200, -200
+        self.assertEqual(x[:], a.tolist())
+
+        self.assertRaises(BufferError, a.append, 100)
+        self.assertRaises(BufferError, a.pop)
+
+        del x; del y; gc.collect(); gc.collect(); gc.collect()
+        a.append(100)
+        a.pop()
+        x = (c_int * 16).from_buffer(a)
+
+        self.assertIn(a, [obj.obj if isinstance(obj, memoryview) else obj
+                          for obj in x._objects.values()])
+
+        expected = x[:]
+        del a; gc.collect(); gc.collect(); gc.collect()
+        self.assertEqual(x[:], expected)
+
+        with self.assertRaisesRegex(TypeError, "not writable"):
+            (c_char * 16).from_buffer(b"a" * 16)
+        with self.assertRaisesRegex(TypeError, "not writable"):
+            (c_char * 16).from_buffer(memoryview(b"a" * 16))
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(memoryview(bytearray(b"a" * 16))[::-1])
+        msg = "bytes-like object is required"
+        with self.assertRaisesRegex(TypeError, msg):
+            (c_char * 16).from_buffer("a" * 16)
+
+    def test_fortran_contiguous(self):
+        try:
+            import _testbuffer
+        except ImportError as err:
+            self.skipTest(str(err))
+        flags = _testbuffer.ND_WRITABLE | _testbuffer.ND_FORTRAN
+        array = _testbuffer.ndarray(
+            [97] * 16, format="B", shape=[4, 4], flags=flags)
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(array)
+        array = memoryview(array)
+        self.assertTrue(array.f_contiguous)
+        self.assertFalse(array.c_contiguous)
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(array)
+
+    def test_from_buffer_with_offset(self):
+        a = array.array("i", range(16))
+        x = (c_int * 15).from_buffer(a, sizeof(c_int))
+
+        self.assertEqual(x[:], a.tolist()[1:])
+        with self.assertRaises(ValueError):
+            c_int.from_buffer(a, -1)
+        with self.assertRaises(ValueError):
+            (c_int * 16).from_buffer(a, sizeof(c_int))
+        with self.assertRaises(ValueError):
+            (c_int * 1).from_buffer(a, 16 * sizeof(c_int))
+
+    def test_from_buffer_memoryview(self):
+        a = [c_char.from_buffer(memoryview(bytearray(b'a')))]
+        a.append(a)
+        del a
+        gc.collect()  # Should not crash
+
+    def test_from_buffer_copy(self):
+        a = array.array("i", range(16))
+        x = (c_int * 16).from_buffer_copy(a)
+
+        y = X.from_buffer_copy(a)
+        self.assertEqual(y.c_int, a[0])
+        self.assertFalse(y.init_called)
+
+        self.assertEqual(x[:], list(range(16)))
+
+        a[0], a[-1] = 200, -200
+        self.assertEqual(x[:], list(range(16)))
+
+        a.append(100)
+        self.assertEqual(x[:], list(range(16)))
+
+        self.assertEqual(x._objects, None)
+
+        del a; gc.collect(); gc.collect(); gc.collect()
+        self.assertEqual(x[:], list(range(16)))
+
+        x = (c_char * 16).from_buffer_copy(b"a" * 16)
+        self.assertEqual(x[:], b"a" * 16)
+        with self.assertRaises(TypeError):
+            (c_char * 16).from_buffer_copy("a" * 16)
+
+    def test_from_buffer_copy_with_offset(self):
+        a = array.array("i", range(16))
+        x = (c_int * 15).from_buffer_copy(a, sizeof(c_int))
+
+        self.assertEqual(x[:], a.tolist()[1:])
+        with self.assertRaises(ValueError):
+            c_int.from_buffer_copy(a, -1)
+        with self.assertRaises(ValueError):
+            (c_int * 16).from_buffer_copy(a, sizeof(c_int))
+        with self.assertRaises(ValueError):
+            (c_int * 1).from_buffer_copy(a, 16 * sizeof(c_int))
+
+    def test_abstract(self):
+        from ctypes import _Pointer, _SimpleCData, _CFuncPtr
+
+        self.assertRaises(TypeError, Array.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, Structure.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, Union.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _CFuncPtr.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _Pointer.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _SimpleCData.from_buffer, bytearray(10))
+
+        self.assertRaises(TypeError, Array.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, Structure.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, Union.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _CFuncPtr.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _Pointer.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _SimpleCData.from_buffer_copy, b"123")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_funcptr.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_funcptr.py
new file mode 100644
index 0000000..e0b9b54
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_funcptr.py
@@ -0,0 +1,132 @@
+import unittest
+from ctypes import *
+
+try:
+    WINFUNCTYPE
+except NameError:
+    # fake to enable this test on Linux
+    WINFUNCTYPE = CFUNCTYPE
+
+import _ctypes_test
+lib = CDLL(_ctypes_test.__file__)
+
+class CFuncPtrTestCase(unittest.TestCase):
+    def test_basic(self):
+        X = WINFUNCTYPE(c_int, c_int, c_int)
+
+        def func(*args):
+            return len(args)
+
+        x = X(func)
+        self.assertEqual(x.restype, c_int)
+        self.assertEqual(x.argtypes, (c_int, c_int))
+        self.assertEqual(sizeof(x), sizeof(c_voidp))
+        self.assertEqual(sizeof(X), sizeof(c_voidp))
+
+    def test_first(self):
+        StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
+        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
+
+        def func(a, b):
+            return a + b
+
+        s = StdCallback(func)
+        c = CdeclCallback(func)
+
+        self.assertEqual(s(1, 2), 3)
+        self.assertEqual(c(1, 2), 3)
+        # The following no longer raises a TypeError - it is now
+        # possible, as in C, to call cdecl functions with more parameters.
+        #self.assertRaises(TypeError, c, 1, 2, 3)
+        self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
+        if not WINFUNCTYPE is CFUNCTYPE:
+            self.assertRaises(TypeError, s, 1, 2, 3)
+
+    def test_structures(self):
+        WNDPROC = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        def wndproc(hwnd, msg, wParam, lParam):
+            return hwnd + msg + wParam + lParam
+
+        HINSTANCE = c_int
+        HICON = c_int
+        HCURSOR = c_int
+        LPCTSTR = c_char_p
+
+        class WNDCLASS(Structure):
+            _fields_ = [("style", c_uint),
+                        ("lpfnWndProc", WNDPROC),
+                        ("cbClsExtra", c_int),
+                        ("cbWndExtra", c_int),
+                        ("hInstance", HINSTANCE),
+                        ("hIcon", HICON),
+                        ("hCursor", HCURSOR),
+                        ("lpszMenuName", LPCTSTR),
+                        ("lpszClassName", LPCTSTR)]
+
+        wndclass = WNDCLASS()
+        wndclass.lpfnWndProc = WNDPROC(wndproc)
+
+        WNDPROC_2 = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        # This is no longer true, now that WINFUNCTYPE caches created types internally.
+        ## # CFuncPtr subclasses are compared by identity, so this raises a TypeError:
+        ## self.assertRaises(TypeError, setattr, wndclass,
+        ##                  "lpfnWndProc", WNDPROC_2(wndproc))
+        # instead:
+
+        self.assertIs(WNDPROC, WNDPROC_2)
+        # 'wndclass.lpfnWndProc' leaks 94 references.  Why?
+        self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
+
+
+        f = wndclass.lpfnWndProc
+
+        del wndclass
+        del wndproc
+
+        self.assertEqual(f(10, 11, 12, 13), 46)
+
+    def test_dllfunctions(self):
+
+        def NoNullHandle(value):
+            if not value:
+                raise WinError()
+            return value
+
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+        strchr.argtypes = (c_char_p, c_char)
+        self.assertEqual(strchr(b"abcdefghi", b"b"), b"bcdefghi")
+        self.assertEqual(strchr(b"abcdefghi", b"x"), None)
+
+
+        strtok = lib.my_strtok
+        strtok.restype = c_char_p
+        # Neither of this does work: strtok changes the buffer it is passed
+##        strtok.argtypes = (c_char_p, c_char_p)
+##        strtok.argtypes = (c_string, c_char_p)
+
+        def c_string(init):
+            size = len(init) + 1
+            return (c_char*size)(*init)
+
+        s = b"a\nb\nc"
+        b = c_string(s)
+
+##        b = (c_char * (len(s)+1))()
+##        b.value = s
+
+##        b = c_string(s)
+        self.assertEqual(strtok(b, b"\n"), b"a")
+        self.assertEqual(strtok(None, b"\n"), b"b")
+        self.assertEqual(strtok(None, b"\n"), b"c")
+        self.assertEqual(strtok(None, b"\n"), None)
+
+    def test_abstract(self):
+        from ctypes import _CFuncPtr
+
+        self.assertRaises(TypeError, _CFuncPtr, 13, "name", 42, "iid")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_functions.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_functions.py
new file mode 100644
index 0000000..fc57170
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_functions.py
@@ -0,0 +1,384 @@
+"""
+Here is probably the place to write the docs, since the test-cases
+show how the type behave.
+
+Later...
+"""
+
+from ctypes import *
+from ctypes.test import need_symbol
+import sys, unittest
+
+try:
+    WINFUNCTYPE
+except NameError:
+    # fake to enable this test on Linux
+    WINFUNCTYPE = CFUNCTYPE
+
+import _ctypes_test
+dll = CDLL(_ctypes_test.__file__)
+if sys.platform == "win32":
+    windll = WinDLL(_ctypes_test.__file__)
+
+class POINT(Structure):
+    _fields_ = [("x", c_int), ("y", c_int)]
+class RECT(Structure):
+    _fields_ = [("left", c_int), ("top", c_int),
+                ("right", c_int), ("bottom", c_int)]
+class FunctionTestCase(unittest.TestCase):
+
+    def test_mro(self):
+        # in Python 2.3, this raises TypeError: MRO conflict among bases classes,
+        # in Python 2.2 it works.
+        #
+        # But in early versions of _ctypes.c, the result of tp_new
+        # wasn't checked, and it even crashed Python.
+        # Found by Greg Chapman.
+
+        with self.assertRaises(TypeError):
+            class X(object, Array):
+                _length_ = 5
+                _type_ = "i"
+
+        from _ctypes import _Pointer
+        with self.assertRaises(TypeError):
+            class X(object, _Pointer):
+                pass
+
+        from _ctypes import _SimpleCData
+        with self.assertRaises(TypeError):
+            class X(object, _SimpleCData):
+                _type_ = "i"
+
+        with self.assertRaises(TypeError):
+            class X(object, Structure):
+                _fields_ = []
+
+    @need_symbol('c_wchar')
+    def test_wchar_parm(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
+        result = f(1, "x", 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 139)
+        self.assertEqual(type(result), int)
+
+    @need_symbol('c_wchar')
+    def test_wchar_result(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_wchar
+        result = f(0, 0, 0, 0, 0, 0)
+        self.assertEqual(result, '\x00')
+
+    def test_voidresult(self):
+        f = dll._testfunc_v
+        f.restype = None
+        f.argtypes = [c_int, c_int, POINTER(c_int)]
+        result = c_int()
+        self.assertEqual(None, f(1, 2, byref(result)))
+        self.assertEqual(result.value, 3)
+
+    def test_intresult(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_int
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), int)
+
+        # If we declare the function to return a short,
+        # is the high part split off?
+        f.restype = c_short
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        result = f(1, 2, 3, 0x10004, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        # You cannot assign character format codes as restype any longer
+        self.assertRaises(TypeError, setattr, f, "restype", "i")
+
+    def test_floatresult(self):
+        f = dll._testfunc_f_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_float
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    def test_doubleresult(self):
+        f = dll._testfunc_d_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_double
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    @need_symbol('c_longdouble')
+    def test_longdoubleresult(self):
+        f = dll._testfunc_D_bhilfD
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
+        f.restype = c_longdouble
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    @need_symbol('c_longlong')
+    def test_longlongresult(self):
+        f = dll._testfunc_q_bhilfd
+        f.restype = c_longlong
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+
+        f = dll._testfunc_q_bhilfdq
+        f.restype = c_longlong
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong]
+        result = f(1, 2, 3, 4, 5.0, 6.0, 21)
+        self.assertEqual(result, 42)
+
+    def test_stringresult(self):
+        f = dll._testfunc_p_p
+        f.argtypes = None
+        f.restype = c_char_p
+        result = f(b"123")
+        self.assertEqual(result, b"123")
+
+        result = f(None)
+        self.assertEqual(result, None)
+
+    def test_pointers(self):
+        f = dll._testfunc_p_p
+        f.restype = POINTER(c_int)
+        f.argtypes = [POINTER(c_int)]
+
+        # This only works if the value c_int(42) passed to the
+        # function is still alive while the pointer (the result) is
+        # used.
+
+        v = c_int(42)
+
+        self.assertEqual(pointer(v).contents.value, 42)
+        result = f(pointer(v))
+        self.assertEqual(type(result), POINTER(c_int))
+        self.assertEqual(result.contents.value, 42)
+
+        # This on works...
+        result = f(pointer(v))
+        self.assertEqual(result.contents.value, v.value)
+
+        p = pointer(c_int(99))
+        result = f(p)
+        self.assertEqual(result.contents.value, 99)
+
+        arg = byref(v)
+        result = f(arg)
+        self.assertNotEqual(result.contents, v.value)
+
+        self.assertRaises(ArgumentError, f, byref(c_short(22)))
+
+        # It is dangerous, however, because you don't control the lifetime
+        # of the pointer:
+        result = f(byref(c_int(99)))
+        self.assertNotEqual(result.contents, 99)
+
+    ################################################################
+    def test_shorts(self):
+        f = dll._testfunc_callback_i_if
+
+        args = []
+        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
+                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+
+        def callback(v):
+            args.append(v)
+            return v
+
+        CallBack = CFUNCTYPE(c_int, c_int)
+
+        cb = CallBack(callback)
+        f(2**18, cb)
+        self.assertEqual(args, expected)
+
+    ################################################################
+
+
+    def test_callbacks(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+        f.argtypes = None
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        def callback(value):
+            #print "called back with", value
+            return value
+
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+        # test with prototype
+        f.argtypes = [c_int, MyCallback]
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+        AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int)
+
+        # check that the prototype works: we call f with wrong
+        # argument types
+        cb = AnotherCallback(callback)
+        self.assertRaises(ArgumentError, f, -10, cb)
+
+
+    def test_callbacks_2(self):
+        # Can also use simple datatypes as argument type specifiers
+        # for the callback function.
+        # In this case the call receives an instance of that type
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        f.argtypes = [c_int, MyCallback]
+
+        def callback(value):
+            #print "called back with", value
+            self.assertEqual(type(value), int)
+            return value
+
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+    @need_symbol('c_longlong')
+    def test_longlong_callbacks(self):
+
+        f = dll._testfunc_callback_q_qf
+        f.restype = c_longlong
+
+        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
+
+        f.argtypes = [c_longlong, MyCallback]
+
+        def callback(value):
+            self.assertIsInstance(value, int)
+            return value & 0x7FFFFFFF
+
+        cb = MyCallback(callback)
+
+        self.assertEqual(13577625587, f(1000000000000, cb))
+
+    def test_errors(self):
+        self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy")
+        self.assertRaises(ValueError, c_int.in_dll, dll, "_xxx_yyy")
+
+    def test_byval(self):
+
+        # without prototype
+        ptin = POINT(1, 2)
+        ptout = POINT()
+        # EXPORT int _testfunc_byval(point in, point *pout)
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 3, 1, 2
+        self.assertEqual(got, expected)
+
+        # with prototype
+        ptin = POINT(101, 102)
+        ptout = POINT()
+        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
+        dll._testfunc_byval.restype = c_int
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 203, 101, 102
+        self.assertEqual(got, expected)
+
+    def test_struct_return_2H(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+        dll.ret_2h_func.restype = S2H
+        dll.ret_2h_func.argtypes = [S2H]
+        inp = S2H(99, 88)
+        s2h = dll.ret_2h_func(inp)
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_struct_return_2H_stdcall(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+
+        windll.s_ret_2h_func.restype = S2H
+        windll.s_ret_2h_func.argtypes = [S2H]
+        s2h = windll.s_ret_2h_func(S2H(99, 88))
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+    def test_struct_return_8H(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        dll.ret_8i_func.restype = S8I
+        dll.ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = dll.ret_8i_func(inp)
+        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_struct_return_8H_stdcall(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        windll.s_ret_8i_func.restype = S8I
+        windll.s_ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = windll.s_ret_8i_func(inp)
+        self.assertEqual(
+                (s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    def test_sf1651235(self):
+        # see https://www.python.org/sf/1651235
+
+        proto = CFUNCTYPE(c_int, RECT, POINT)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT()))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_incomplete.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_incomplete.py
new file mode 100644
index 0000000..00c430e
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_incomplete.py
@@ -0,0 +1,42 @@
+import unittest
+from ctypes import *
+
+################################################################
+#
+# The incomplete pointer example from the tutorial
+#
+
+class MyTestCase(unittest.TestCase):
+
+    def test_incomplete_example(self):
+        lpcell = POINTER("cell")
+        class cell(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("next", lpcell)]
+
+        SetPointerType(lpcell, cell)
+
+        c1 = cell()
+        c1.name = b"foo"
+        c2 = cell()
+        c2.name = b"bar"
+
+        c1.next = pointer(c2)
+        c2.next = pointer(c1)
+
+        p = c1
+
+        result = []
+        for i in range(8):
+            result.append(p.name)
+            p = p.next[0]
+        self.assertEqual(result, [b"foo", b"bar"] * 4)
+
+        # to not leak references, we must clean _pointer_type_cache
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[cell]
+
+################################################################
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_init.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_init.py
new file mode 100644
index 0000000..75fad11
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_init.py
@@ -0,0 +1,40 @@
+from ctypes import *
+import unittest
+
+class X(Structure):
+    _fields_ = [("a", c_int),
+                ("b", c_int)]
+    new_was_called = False
+
+    def __new__(cls):
+        result = super().__new__(cls)
+        result.new_was_called = True
+        return result
+
+    def __init__(self):
+        self.a = 9
+        self.b = 12
+
+class Y(Structure):
+    _fields_ = [("x", X)]
+
+
+class InitTest(unittest.TestCase):
+    def test_get(self):
+        # make sure the only accessing a nested structure
+        # doesn't call the structure's __new__ and __init__
+        y = Y()
+        self.assertEqual((y.x.a, y.x.b), (0, 0))
+        self.assertEqual(y.x.new_was_called, False)
+
+        # But explicitly creating an X structure calls __new__ and __init__, of course.
+        x = X()
+        self.assertEqual((x.a, x.b), (9, 12))
+        self.assertEqual(x.new_was_called, True)
+
+        y.x = x
+        self.assertEqual((y.x.a, y.x.b), (9, 12))
+        self.assertEqual(y.x.new_was_called, False)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_internals.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_internals.py
new file mode 100644
index 0000000..271e3f5
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_internals.py
@@ -0,0 +1,100 @@
+# This tests the internal _objects attribute
+import unittest
+from ctypes import *
+from sys import getrefcount as grc
+
+# XXX This test must be reviewed for correctness!!!
+
+# ctypes' types are container types.
+#
+# They have an internal memory block, which only consists of some bytes,
+# but it has to keep references to other objects as well. This is not
+# really needed for trivial C types like int or char, but it is important
+# for aggregate types like strings or pointers in particular.
+#
+# What about pointers?
+
+class ObjectsTestCase(unittest.TestCase):
+    def assertSame(self, a, b):
+        self.assertEqual(id(a), id(b))
+
+    def test_ints(self):
+        i = 42000123
+        refcnt = grc(i)
+        ci = c_int(i)
+        self.assertEqual(refcnt, grc(i))
+        self.assertEqual(ci._objects, None)
+
+    def test_c_char_p(self):
+        s = b"Hello, World"
+        refcnt = grc(s)
+        cs = c_char_p(s)
+        self.assertEqual(refcnt + 1, grc(s))
+        self.assertSame(cs._objects, s)
+
+    def test_simple_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+
+        a = 421234
+        b = 421235
+        x = X()
+        self.assertEqual(x._objects, None)
+        x.a = a
+        x.b = b
+        self.assertEqual(x._objects, None)
+
+    def test_embedded_structs(self):
+        class X(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+
+        class Y(Structure):
+            _fields_ = [("x", X), ("y", X)]
+
+        y = Y()
+        self.assertEqual(y._objects, None)
+
+        x1, x2 = X(), X()
+        y.x, y.y = x1, x2
+        self.assertEqual(y._objects, {"0": {}, "1": {}})
+        x1.a, x2.b = 42, 93
+        self.assertEqual(y._objects, {"0": {}, "1": {}})
+
+    def test_xxx(self):
+        class X(Structure):
+            _fields_ = [("a", c_char_p), ("b", c_char_p)]
+
+        class Y(Structure):
+            _fields_ = [("x", X), ("y", X)]
+
+        s1 = b"Hello, World"
+        s2 = b"Hallo, Welt"
+
+        x = X()
+        x.a = s1
+        x.b = s2
+        self.assertEqual(x._objects, {"0": s1, "1": s2})
+
+        y = Y()
+        y.x = x
+        self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}})
+##        x = y.x
+##        del y
+##        print x._b_base_._objects
+
+    def test_ptr_struct(self):
+        class X(Structure):
+            _fields_ = [("data", POINTER(c_int))]
+
+        A = c_int*4
+        a = A(11, 22, 33, 44)
+        self.assertEqual(a._objects, None)
+
+        x = X()
+        x.data = a
+##XXX        print x._objects
+##XXX        print x.data[0]
+##XXX        print x.data._objects
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_keeprefs.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_keeprefs.py
new file mode 100644
index 0000000..e20adc7
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_keeprefs.py
@@ -0,0 +1,122 @@
+from ctypes import *
+import unittest
+
+class SimpleTestCase(unittest.TestCase):
+    def test_cint(self):
+        x = c_int()
+        self.assertEqual(x._objects, None)
+        x.value = 42
+        self.assertEqual(x._objects, None)
+        x = c_int(99)
+        self.assertEqual(x._objects, None)
+
+    def test_ccharp(self):
+        x = c_char_p()
+        self.assertEqual(x._objects, None)
+        x.value = b"abc"
+        self.assertEqual(x._objects, b"abc")
+        x = c_char_p(b"spam")
+        self.assertEqual(x._objects, b"spam")
+
+class StructureTestCase(unittest.TestCase):
+    def test_cint_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int)]
+
+        x = X()
+        self.assertEqual(x._objects, None)
+        x.a = 42
+        x.b = 99
+        self.assertEqual(x._objects, None)
+
+    def test_ccharp_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_char_p),
+                        ("b", c_char_p)]
+        x = X()
+        self.assertEqual(x._objects, None)
+
+        x.a = b"spam"
+        x.b = b"foo"
+        self.assertEqual(x._objects, {"0": b"spam", "1": b"foo"})
+
+    def test_struct_struct(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        class RECT(Structure):
+            _fields_ = [("ul", POINT), ("lr", POINT)]
+
+        r = RECT()
+        r.ul.x = 0
+        r.ul.y = 1
+        r.lr.x = 2
+        r.lr.y = 3
+        self.assertEqual(r._objects, None)
+
+        r = RECT()
+        pt = POINT(1, 2)
+        r.ul = pt
+        self.assertEqual(r._objects, {'0': {}})
+        r.ul.x = 22
+        r.ul.y = 44
+        self.assertEqual(r._objects, {'0': {}})
+        r.lr = POINT()
+        self.assertEqual(r._objects, {'0': {}, '1': {}})
+
+class ArrayTestCase(unittest.TestCase):
+    def test_cint_array(self):
+        INTARR = c_int * 3
+
+        ia = INTARR()
+        self.assertEqual(ia._objects, None)
+        ia[0] = 1
+        ia[1] = 2
+        ia[2] = 3
+        self.assertEqual(ia._objects, None)
+
+        class X(Structure):
+            _fields_ = [("x", c_int),
+                        ("a", INTARR)]
+
+        x = X()
+        x.x = 1000
+        x.a[0] = 42
+        x.a[1] = 96
+        self.assertEqual(x._objects, None)
+        x.a = ia
+        self.assertEqual(x._objects, {'1': {}})
+
+class PointerTestCase(unittest.TestCase):
+    def test_p_cint(self):
+        i = c_int(42)
+        x = pointer(i)
+        self.assertEqual(x._objects, {'1': i})
+
+
+class PointerToStructure(unittest.TestCase):
+    def test(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        class RECT(Structure):
+            _fields_ = [("a", POINTER(POINT)),
+                        ("b", POINTER(POINT))]
+        r = RECT()
+        p1 = POINT(1, 2)
+
+        r.a = pointer(p1)
+        r.b = pointer(p1)
+##        from pprint import pprint as pp
+##        pp(p1._objects)
+##        pp(r._objects)
+
+        r.a[0].x = 42
+        r.a[0].y = 99
+
+        # to avoid leaking when tests are run several times
+        # clean up the types left in the cache.
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[POINT]
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_libc.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_libc.py
new file mode 100644
index 0000000..56285b5
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_libc.py
@@ -0,0 +1,33 @@
+import unittest
+
+from ctypes import *
+import _ctypes_test
+
+lib = CDLL(_ctypes_test.__file__)
+
+def three_way_cmp(x, y):
+    """Return -1 if x < y, 0 if x == y and 1 if x > y"""
+    return (x > y) - (x < y)
+
+class LibTest(unittest.TestCase):
+    def test_sqrt(self):
+        lib.my_sqrt.argtypes = c_double,
+        lib.my_sqrt.restype = c_double
+        self.assertEqual(lib.my_sqrt(4.0), 2.0)
+        import math
+        self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
+
+    def test_qsort(self):
+        comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char))
+        lib.my_qsort.argtypes = c_void_p, c_size_t, c_size_t, comparefunc
+        lib.my_qsort.restype = None
+
+        def sort(a, b):
+            return three_way_cmp(a[0], b[0])
+
+        chars = create_string_buffer(b"spam, spam, and spam")
+        lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
+        self.assertEqual(chars.raw, b"   ,,aaaadmmmnpppsss\x00")
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_loading.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_loading.py
new file mode 100644
index 0000000..ea89227
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_loading.py
@@ -0,0 +1,182 @@
+from ctypes import *
+import os
+import shutil
+import subprocess
+import sys
+import unittest
+import test.support
+from test.support import import_helper
+from test.support import os_helper
+from ctypes.util import find_library
+
+libc_name = None
+
+def setUpModule():
+    global libc_name
+    if os.name == "nt":
+        libc_name = find_library("c")
+    elif sys.platform == "cygwin":
+        libc_name = "cygwin1.dll"
+    else:
+        libc_name = find_library("c")
+
+    if test.support.verbose:
+        print("libc_name is", libc_name)
+
+class LoaderTest(unittest.TestCase):
+
+    unknowndll = "xxrandomnamexx"
+
+    def test_load(self):
+        if libc_name is None:
+            self.skipTest('could not find libc')
+        CDLL(libc_name)
+        CDLL(os.path.basename(libc_name))
+        self.assertRaises(OSError, CDLL, self.unknowndll)
+
+    def test_load_version(self):
+        if libc_name is None:
+            self.skipTest('could not find libc')
+        if os.path.basename(libc_name) != 'libc.so.6':
+            self.skipTest('wrong libc path for test')
+        cdll.LoadLibrary("libc.so.6")
+        # linux uses version, libc 9 should not exist
+        self.assertRaises(OSError, cdll.LoadLibrary, "libc.so.9")
+        self.assertRaises(OSError, cdll.LoadLibrary, self.unknowndll)
+
+    def test_find(self):
+        for name in ("c", "m"):
+            lib = find_library(name)
+            if lib:
+                cdll.LoadLibrary(lib)
+                CDLL(lib)
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_library(self):
+        # CRT is no longer directly loadable. See issue23606 for the
+        # discussion about alternative approaches.
+        #self.assertIsNotNone(libc_name)
+        if test.support.verbose:
+            print(find_library("kernel32"))
+            print(find_library("user32"))
+
+        if os.name == "nt":
+            windll.kernel32.GetModuleHandleW
+            windll["kernel32"].GetModuleHandleW
+            windll.LoadLibrary("kernel32").GetModuleHandleW
+            WinDLL("kernel32").GetModuleHandleW
+            # embedded null character
+            self.assertRaises(ValueError, windll.LoadLibrary, "kernel32\0")
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_ordinal_functions(self):
+        import _ctypes_test
+        dll = WinDLL(_ctypes_test.__file__)
+        # We load the same function both via ordinal and name
+        func_ord = dll[2]
+        func_name = dll.GetString
+        # addressof gets the address where the function pointer is stored
+        a_ord = addressof(func_ord)
+        a_name = addressof(func_name)
+        f_ord_addr = c_void_p.from_address(a_ord).value
+        f_name_addr = c_void_p.from_address(a_name).value
+        self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
+
+        self.assertRaises(AttributeError, dll.__getitem__, 1234)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_A(self):
+        from _ctypes import LoadLibrary, FreeLibrary
+        # On winXP 64-bit, advapi32 loads at an address that does
+        # NOT fit into a 32-bit integer.  FreeLibrary must be able
+        # to accept this address.
+
+        # These are tests for https://www.python.org/sf/1703286
+        handle = LoadLibrary("advapi32")
+        FreeLibrary(handle)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_B(self):
+        # Since on winXP 64-bit advapi32 loads like described
+        # above, the (arbitrarily selected) CloseEventLog function
+        # also has a high address.  'call_function' should accept
+        # addresses so large.
+        from _ctypes import call_function
+        advapi32 = windll.advapi32
+        # Calling CloseEventLog with a NULL argument should fail,
+        # but the call should not segfault or so.
+        self.assertEqual(0, advapi32.CloseEventLog(None))
+        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        windll.kernel32.GetProcAddress.restype = c_void_p
+        proc = windll.kernel32.GetProcAddress(advapi32._handle,
+                                              b"CloseEventLog")
+        self.assertTrue(proc)
+        # This is the real test: call the function via 'call_function'
+        self.assertEqual(0, call_function(proc, (None,)))
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_dll_with_flags(self):
+        _sqlite3 = import_helper.import_module("_sqlite3")
+        src = _sqlite3.__file__
+        if src.lower().endswith("_d.pyd"):
+            ext = "_d.dll"
+        else:
+            ext = ".dll"
+
+        with os_helper.temp_dir() as tmp:
+            # We copy two files and load _sqlite3.dll (formerly .pyd),
+            # which has a dependency on sqlite3.dll. Then we test
+            # loading it in subprocesses to avoid it starting in memory
+            # for each test.
+            target = os.path.join(tmp, "_sqlite3.dll")
+            shutil.copy(src, target)
+            shutil.copy(os.path.join(os.path.dirname(src), "sqlite3" + ext),
+                        os.path.join(tmp, "sqlite3" + ext))
+
+            def should_pass(command):
+                with self.subTest(command):
+                    subprocess.check_output(
+                        [sys.executable, "-c",
+                         "from ctypes import *; import nt;" + command],
+                        cwd=tmp
+                    )
+
+            def should_fail(command):
+                with self.subTest(command):
+                    with self.assertRaises(subprocess.CalledProcessError):
+                        subprocess.check_output(
+                            [sys.executable, "-c",
+                             "from ctypes import *; import nt;" + command],
+                            cwd=tmp, stderr=subprocess.STDOUT,
+                        )
+
+            # Default load should not find this in CWD
+            should_fail("WinDLL('_sqlite3.dll')")
+
+            # Relative path (but not just filename) should succeed
+            should_pass("WinDLL('./_sqlite3.dll')")
+
+            # Insecure load flags should succeed
+            # Clear the DLL directory to avoid safe search settings propagating
+            should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
+
+            # Full path load without DLL_LOAD_DIR shouldn't find dependency
+            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
+
+            # Full path load with DLL_LOAD_DIR should succeed
+            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
+                        "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
+
+            # User-specified directory should succeed
+            should_pass("import os; p = os.add_dll_directory(os.getcwd());" +
+                        "WinDLL('_sqlite3.dll'); p.close()")
+
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_macholib.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_macholib.py
new file mode 100644
index 0000000..bc75f1a
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_macholib.py
@@ -0,0 +1,110 @@
+import os
+import sys
+import unittest
+
+# Bob Ippolito:
+#
+# Ok.. the code to find the filename for __getattr__ should look
+# something like:
+#
+# import os
+# from macholib.dyld import dyld_find
+#
+# def find_lib(name):
+#      possible = ['lib'+name+'.dylib', name+'.dylib',
+#      name+'.framework/'+name]
+#      for dylib in possible:
+#          try:
+#              return os.path.realpath(dyld_find(dylib))
+#          except ValueError:
+#              pass
+#      raise ValueError, "%s not found" % (name,)
+#
+# It'll have output like this:
+#
+#  >>> find_lib('pthread')
+# '/usr/lib/libSystem.B.dylib'
+#  >>> find_lib('z')
+# '/usr/lib/libz.1.dylib'
+#  >>> find_lib('IOKit')
+# '/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit'
+#
+# -bob
+
+from ctypes.macholib.dyld import dyld_find
+from ctypes.macholib.dylib import dylib_info
+from ctypes.macholib.framework import framework_info
+
+def find_lib(name):
+    possible = ['lib'+name+'.dylib', name+'.dylib', name+'.framework/'+name]
+    for dylib in possible:
+        try:
+            return os.path.realpath(dyld_find(dylib))
+        except ValueError:
+            pass
+    raise ValueError("%s not found" % (name,))
+
+
+def d(location=None, name=None, shortname=None, version=None, suffix=None):
+    return {'location': location, 'name': name, 'shortname': shortname,
+            'version': version, 'suffix': suffix}
+
+
+class MachOTest(unittest.TestCase):
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_find(self):
+        self.assertEqual(dyld_find('libSystem.dylib'),
+                         '/usr/lib/libSystem.dylib')
+        self.assertEqual(dyld_find('System.framework/System'),
+                         '/System/Library/Frameworks/System.framework/System')
+
+        # On Mac OS 11, system dylibs are only present in the shared cache,
+        # so symlinks like libpthread.dylib -> libSystem.B.dylib will not
+        # be resolved by dyld_find
+        self.assertIn(find_lib('pthread'),
+                              ('/usr/lib/libSystem.B.dylib', '/usr/lib/libpthread.dylib'))
+
+        result = find_lib('z')
+        # Issue #21093: dyld default search path includes $HOME/lib and
+        # /usr/local/lib before /usr/lib, which caused test failures if
+        # a local copy of libz exists in one of them. Now ignore the head
+        # of the path.
+        self.assertRegex(result, r".*/lib/libz.*\.dylib")
+
+        self.assertIn(find_lib('IOKit'),
+                              ('/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit',
+                              '/System/Library/Frameworks/IOKit.framework/IOKit'))
+
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_info(self):
+        self.assertIsNone(dylib_info('completely/invalid'))
+        self.assertIsNone(dylib_info('completely/invalide_debug'))
+        self.assertEqual(dylib_info('P/Foo.dylib'), d('P', 'Foo.dylib', 'Foo'))
+        self.assertEqual(dylib_info('P/Foo_debug.dylib'),
+                         d('P', 'Foo_debug.dylib', 'Foo', suffix='debug'))
+        self.assertEqual(dylib_info('P/Foo.A.dylib'),
+                         d('P', 'Foo.A.dylib', 'Foo', 'A'))
+        self.assertEqual(dylib_info('P/Foo_debug.A.dylib'),
+                         d('P', 'Foo_debug.A.dylib', 'Foo_debug', 'A'))
+        self.assertEqual(dylib_info('P/Foo.A_debug.dylib'),
+                         d('P', 'Foo.A_debug.dylib', 'Foo', 'A', 'debug'))
+
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_framework_info(self):
+        self.assertIsNone(framework_info('completely/invalid'))
+        self.assertIsNone(framework_info('completely/invalid/_debug'))
+        self.assertIsNone(framework_info('P/F.framework'))
+        self.assertIsNone(framework_info('P/F.framework/_debug'))
+        self.assertEqual(framework_info('P/F.framework/F'),
+                         d('P', 'F.framework/F', 'F'))
+        self.assertEqual(framework_info('P/F.framework/F_debug'),
+                         d('P', 'F.framework/F_debug', 'F', suffix='debug'))
+        self.assertIsNone(framework_info('P/F.framework/Versions'))
+        self.assertIsNone(framework_info('P/F.framework/Versions/A'))
+        self.assertEqual(framework_info('P/F.framework/Versions/A/F'),
+                         d('P', 'F.framework/Versions/A/F', 'F', 'A'))
+        self.assertEqual(framework_info('P/F.framework/Versions/A/F_debug'),
+                         d('P', 'F.framework/Versions/A/F_debug', 'F', 'A', 'debug'))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_memfunctions.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_memfunctions.py
new file mode 100644
index 0000000..e784b9a
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_memfunctions.py
@@ -0,0 +1,79 @@
+import sys
+from test import support
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+
+class MemFunctionsTest(unittest.TestCase):
+    @unittest.skip('test disabled')
+    def test_overflow(self):
+        # string_at and wstring_at must use the Python calling
+        # convention (which acquires the GIL and checks the Python
+        # error flag).  Provoke an error and catch it; see also issue
+        # #3554: <http://bugs.python.org/issue3554>
+        self.assertRaises((OverflowError, MemoryError, SystemError),
+                          lambda: wstring_at(u"foo", sys.maxint - 1))
+        self.assertRaises((OverflowError, MemoryError, SystemError),
+                          lambda: string_at("foo", sys.maxint - 1))
+
+    def test_memmove(self):
+        # large buffers apparently increase the chance that the memory
+        # is allocated in high address space.
+        a = create_string_buffer(1000000)
+        p = b"Hello, World"
+        result = memmove(a, p, len(p))
+        self.assertEqual(a.value, b"Hello, World")
+
+        self.assertEqual(string_at(result), b"Hello, World")
+        self.assertEqual(string_at(result, 5), b"Hello")
+        self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
+        self.assertEqual(string_at(result, 0), b"")
+
+    def test_memset(self):
+        a = create_string_buffer(1000000)
+        result = memset(a, ord('x'), 16)
+        self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx")
+
+        self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
+        self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
+        self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
+
+    def test_cast(self):
+        a = (c_ubyte * 32)(*map(ord, "abcdef"))
+        self.assertEqual(cast(a, c_char_p).value, b"abcdef")
+        self.assertEqual(cast(a, POINTER(c_byte))[:7],
+                             [97, 98, 99, 100, 101, 102, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:],
+                             [97, 98, 99, 100, 101, 102, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[6:-1:-1],
+                             [0, 102, 101, 100, 99, 98, 97])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:2],
+                             [97, 99, 101, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:7],
+                             [97])
+
+    @support.refcount_test
+    def test_string_at(self):
+        s = string_at(b"foo bar")
+        # XXX The following may be wrong, depending on how Python
+        # manages string instances
+        self.assertEqual(2, sys.getrefcount(s))
+        self.assertTrue(s, "foo bar")
+
+        self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
+        self.assertEqual(string_at(b"foo bar", 3), b"foo")
+
+    @need_symbol('create_unicode_buffer')
+    def test_wstring_at(self):
+        p = create_unicode_buffer("Hello, World")
+        a = create_unicode_buffer(1000000)
+        result = memmove(a, p, len(p) * sizeof(c_wchar))
+        self.assertEqual(a.value, "Hello, World")
+
+        self.assertEqual(wstring_at(a), "Hello, World")
+        self.assertEqual(wstring_at(a, 5), "Hello")
+        self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
+        self.assertEqual(wstring_at(a, 0), "")
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_numbers.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_numbers.py
new file mode 100644
index 0000000..a769637
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_numbers.py
@@ -0,0 +1,218 @@
+from ctypes import *
+import unittest
+import struct
+
+def valid_ranges(*types):
+    # given a sequence of numeric types, collect their _type_
+    # attribute, which is a single format character compatible with
+    # the struct module, use the struct module to calculate the
+    # minimum and maximum value allowed for this format.
+    # Returns a list of (min, max) values.
+    result = []
+    for t in types:
+        fmt = t._type_
+        size = struct.calcsize(fmt)
+        a = struct.unpack(fmt, (b"\x00"*32)[:size])[0]
+        b = struct.unpack(fmt, (b"\xFF"*32)[:size])[0]
+        c = struct.unpack(fmt, (b"\x7F"+b"\x00"*32)[:size])[0]
+        d = struct.unpack(fmt, (b"\x80"+b"\xFF"*32)[:size])[0]
+        result.append((min(a, b, c, d), max(a, b, c, d)))
+    return result
+
+ArgType = type(byref(c_int(0)))
+
+unsigned_types = [c_ubyte, c_ushort, c_uint, c_ulong]
+signed_types = [c_byte, c_short, c_int, c_long, c_longlong]
+
+bool_types = []
+
+float_types = [c_double, c_float]
+
+try:
+    c_ulonglong
+    c_longlong
+except NameError:
+    pass
+else:
+    unsigned_types.append(c_ulonglong)
+    signed_types.append(c_longlong)
+
+try:
+    c_bool
+except NameError:
+    pass
+else:
+    bool_types.append(c_bool)
+
+unsigned_ranges = valid_ranges(*unsigned_types)
+signed_ranges = valid_ranges(*signed_types)
+bool_values = [True, False, 0, 1, -1, 5000, 'test', [], [1]]
+
+################################################################
+
+class NumberTestCase(unittest.TestCase):
+
+    def test_default_init(self):
+        # default values are set to zero
+        for t in signed_types + unsigned_types + float_types:
+            self.assertEqual(t().value, 0)
+
+    def test_unsigned_values(self):
+        # the value given to the constructor is available
+        # as the 'value' attribute
+        for t, (l, h) in zip(unsigned_types, unsigned_ranges):
+            self.assertEqual(t(l).value, l)
+            self.assertEqual(t(h).value, h)
+
+    def test_signed_values(self):
+        # see above
+        for t, (l, h) in zip(signed_types, signed_ranges):
+            self.assertEqual(t(l).value, l)
+            self.assertEqual(t(h).value, h)
+
+    def test_bool_values(self):
+        from operator import truth
+        for t, v in zip(bool_types, bool_values):
+            self.assertEqual(t(v).value, truth(v))
+
+    def test_typeerror(self):
+        # Only numbers are allowed in the constructor,
+        # otherwise TypeError is raised
+        for t in signed_types + unsigned_types + float_types:
+            self.assertRaises(TypeError, t, "")
+            self.assertRaises(TypeError, t, None)
+
+    def test_from_param(self):
+        # the from_param class method attribute always
+        # returns PyCArgObject instances
+        for t in signed_types + unsigned_types + float_types:
+            self.assertEqual(ArgType, type(t.from_param(0)))
+
+    def test_byref(self):
+        # calling byref returns also a PyCArgObject instance
+        for t in signed_types + unsigned_types + float_types + bool_types:
+            parm = byref(t())
+            self.assertEqual(ArgType, type(parm))
+
+
+    def test_floats(self):
+        # c_float and c_double can be created from
+        # Python int and float
+        class FloatLike:
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
+        for t in float_types:
+            self.assertEqual(t(2.0).value, 2.0)
+            self.assertEqual(t(2).value, 2.0)
+            self.assertEqual(t(2).value, 2.0)
+            self.assertEqual(t(f).value, 2.0)
+
+    def test_integers(self):
+        class FloatLike:
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
+        class IntLike:
+            def __int__(self):
+                return 2
+        d = IntLike()
+        class IndexLike:
+            def __index__(self):
+                return 2
+        i = IndexLike()
+        # integers cannot be constructed from floats,
+        # but from integer-like objects
+        for t in signed_types + unsigned_types:
+            self.assertRaises(TypeError, t, 3.14)
+            self.assertRaises(TypeError, t, f)
+            self.assertRaises(TypeError, t, d)
+            self.assertEqual(t(i).value, 2)
+
+    def test_sizes(self):
+        for t in signed_types + unsigned_types + float_types + bool_types:
+            try:
+                size = struct.calcsize(t._type_)
+            except struct.error:
+                continue
+            # sizeof of the type...
+            self.assertEqual(sizeof(t), size)
+            # and sizeof of an instance
+            self.assertEqual(sizeof(t()), size)
+
+    def test_alignments(self):
+        for t in signed_types + unsigned_types + float_types:
+            code = t._type_ # the typecode
+            align = struct.calcsize("c%c" % code) - struct.calcsize(code)
+
+            # alignment of the type...
+            self.assertEqual((code, alignment(t)),
+                                 (code, align))
+            # and alignment of an instance
+            self.assertEqual((code, alignment(t())),
+                                 (code, align))
+
+    def test_int_from_address(self):
+        from array import array
+        for t in signed_types + unsigned_types:
+            # the array module doesn't support all format codes
+            # (no 'q' or 'Q')
+            try:
+                array(t._type_)
+            except ValueError:
+                continue
+            a = array(t._type_, [100])
+
+            # v now is an integer at an 'external' memory location
+            v = t.from_address(a.buffer_info()[0])
+            self.assertEqual(v.value, a[0])
+            self.assertEqual(type(v), t)
+
+            # changing the value at the memory location changes v's value also
+            a[0] = 42
+            self.assertEqual(v.value, a[0])
+
+
+    def test_float_from_address(self):
+        from array import array
+        for t in float_types:
+            a = array(t._type_, [3.14])
+            v = t.from_address(a.buffer_info()[0])
+            self.assertEqual(v.value, a[0])
+            self.assertIs(type(v), t)
+            a[0] = 2.3456e17
+            self.assertEqual(v.value, a[0])
+            self.assertIs(type(v), t)
+
+    def test_char_from_address(self):
+        from ctypes import c_char
+        from array import array
+
+        a = array('b', [0])
+        a[0] = ord('x')
+        v = c_char.from_address(a.buffer_info()[0])
+        self.assertEqual(v.value, b'x')
+        self.assertIs(type(v), c_char)
+
+        a[0] = ord('?')
+        self.assertEqual(v.value, b'?')
+
+    def test_init(self):
+        # c_int() can be initialized from Python's int, and c_int.
+        # Not from c_long or so, which seems strange, abc should
+        # probably be changed:
+        self.assertRaises(TypeError, c_int, c_long(42))
+
+    def test_float_overflow(self):
+        import sys
+        big_int = int(sys.float_info.max) * 2
+        for t in float_types + [c_longdouble]:
+            self.assertRaises(OverflowError, t, big_int)
+            if (hasattr(t, "__ctype_be__")):
+                self.assertRaises(OverflowError, t.__ctype_be__, big_int)
+            if (hasattr(t, "__ctype_le__")):
+                self.assertRaises(OverflowError, t.__ctype_le__, big_int)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_objects.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_objects.py
new file mode 100644
index 0000000..19e3dc1
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_objects.py
@@ -0,0 +1,67 @@
+r'''
+This tests the '_objects' attribute of ctypes instances.  '_objects'
+holds references to objects that must be kept alive as long as the
+ctypes instance, to make sure that the memory buffer is valid.
+
+WARNING: The '_objects' attribute is exposed ONLY for debugging ctypes itself,
+it MUST NEVER BE MODIFIED!
+
+'_objects' is initialized to a dictionary on first use, before that it
+is None.
+
+Here is an array of string pointers:
+
+>>> from ctypes import *
+>>> array = (c_char_p * 5)()
+>>> print(array._objects)
+None
+>>>
+
+The memory block stores pointers to strings, and the strings itself
+assigned from Python must be kept.
+
+>>> array[4] = b'foo bar'
+>>> array._objects
+{'4': b'foo bar'}
+>>> array[4]
+b'foo bar'
+>>>
+
+It gets more complicated when the ctypes instance itself is contained
+in a 'base' object.
+
+>>> class X(Structure):
+...     _fields_ = [("x", c_int), ("y", c_int), ("array", c_char_p * 5)]
+...
+>>> x = X()
+>>> print(x._objects)
+None
+>>>
+
+The'array' attribute of the 'x' object shares part of the memory buffer
+of 'x' ('_b_base_' is either None, or the root object owning the memory block):
+
+>>> print(x.array._b_base_) # doctest: +ELLIPSIS
+<ctypes.test.test_objects.X object at 0x...>
+>>>
+
+>>> x.array[0] = b'spam spam spam'
+>>> x._objects
+{'0:2': b'spam spam spam'}
+>>> x.array._b_base_._objects
+{'0:2': b'spam spam spam'}
+>>>
+
+'''
+
+import unittest, doctest
+
+import ctypes.test.test_objects
+
+class TestCase(unittest.TestCase):
+    def test(self):
+        failures, tests = doctest.testmod(ctypes.test.test_objects)
+        self.assertFalse(failures, 'doctests failed, see output above')
+
+if __name__ == '__main__':
+    doctest.testmod(ctypes.test.test_objects)
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_parameters.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_parameters.py
new file mode 100644
index 0000000..59c94e3
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_parameters.py
@@ -0,0 +1,302 @@
+import unittest
+from ctypes.test import need_symbol
+import test.support
+
+class SimpleTypesTestCase(unittest.TestCase):
+
+    def setUp(self):
+        import ctypes
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            self.prev_conv_mode = set_conversion_mode("ascii", "strict")
+
+    def tearDown(self):
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            set_conversion_mode(*self.prev_conv_mode)
+
+    def test_subclasses(self):
+        from ctypes import c_void_p, c_char_p
+        # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new
+        class CVOIDP(c_void_p):
+            def from_param(cls, value):
+                return value * 2
+            from_param = classmethod(from_param)
+
+        class CCHARP(c_char_p):
+            def from_param(cls, value):
+                return value * 4
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
+        self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
+
+    @need_symbol('c_wchar_p')
+    def test_subclasses_c_wchar_p(self):
+        from ctypes import c_wchar_p
+
+        class CWCHARP(c_wchar_p):
+            def from_param(cls, value):
+                return value * 3
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
+
+    # XXX Replace by c_char_p tests
+    def test_cstrings(self):
+        from ctypes import c_char_p
+
+        # c_char_p.from_param on a Python String packs the string
+        # into a cparam object
+        s = b"123"
+        self.assertIs(c_char_p.from_param(s)._obj, s)
+
+        # new in 0.9.1: convert (encode) unicode to ascii
+        self.assertEqual(c_char_p.from_param(b"123")._obj, b"123")
+        self.assertRaises(TypeError, c_char_p.from_param, "123\377")
+        self.assertRaises(TypeError, c_char_p.from_param, 42)
+
+        # calling c_char_p.from_param with a c_char_p instance
+        # returns the argument itself:
+        a = c_char_p(b"123")
+        self.assertIs(c_char_p.from_param(a), a)
+
+    @need_symbol('c_wchar_p')
+    def test_cw_strings(self):
+        from ctypes import c_wchar_p
+
+        c_wchar_p.from_param("123")
+
+        self.assertRaises(TypeError, c_wchar_p.from_param, 42)
+        self.assertRaises(TypeError, c_wchar_p.from_param, b"123\377")
+
+        pa = c_wchar_p.from_param(c_wchar_p("123"))
+        self.assertEqual(type(pa), c_wchar_p)
+
+    def test_int_pointers(self):
+        from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer
+        LPINT = POINTER(c_int)
+
+##        p = pointer(c_int(42))
+##        x = LPINT.from_param(p)
+        x = LPINT.from_param(pointer(c_int(42)))
+        self.assertEqual(x.contents.value, 42)
+        self.assertEqual(LPINT(c_int(42)).contents.value, 42)
+
+        self.assertEqual(LPINT.from_param(None), None)
+
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_uint(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_short(42)))
+
+    def test_byref_pointer(self):
+        # The from_param class method of POINTER(typ) classes accepts what is
+        # returned by byref(obj), it type(obj) == typ
+        from ctypes import c_short, c_uint, c_int, c_long, POINTER, byref
+        LPINT = POINTER(c_int)
+
+        LPINT.from_param(byref(c_int(42)))
+
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_short(22)))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, byref(c_long(22)))
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_uint(22)))
+
+    def test_byref_pointerpointer(self):
+        # See above
+        from ctypes import c_short, c_uint, c_int, c_long, pointer, POINTER, byref
+
+        LPLPINT = POINTER(POINTER(c_int))
+        LPLPINT.from_param(byref(pointer(c_int(42))))
+
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_short(22))))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_long(22))))
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_uint(22))))
+
+    def test_array_pointers(self):
+        from ctypes import c_short, c_uint, c_int, c_long, POINTER
+        INTARRAY = c_int * 3
+        ia = INTARRAY()
+        self.assertEqual(len(ia), 3)
+        self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
+
+        # Pointers are only compatible with arrays containing items of
+        # the same type!
+        LPINT = POINTER(c_int)
+        LPINT.from_param((c_int*3)())
+        self.assertRaises(TypeError, LPINT.from_param, c_short*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_long*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_uint*3)
+
+    def test_noctypes_argtype(self):
+        import _ctypes_test
+        from ctypes import CDLL, c_void_p, ArgumentError
+
+        func = CDLL(_ctypes_test.__file__)._testfunc_p_p
+        func.restype = c_void_p
+        # TypeError: has no from_param method
+        self.assertRaises(TypeError, setattr, func, "argtypes", (object,))
+
+        class Adapter:
+            def from_param(cls, obj):
+                return None
+
+        func.argtypes = (Adapter(),)
+        self.assertEqual(func(None), None)
+        self.assertEqual(func(object()), None)
+
+        class Adapter:
+            def from_param(cls, obj):
+                return obj
+
+        func.argtypes = (Adapter(),)
+        # don't know how to convert parameter 1
+        self.assertRaises(ArgumentError, func, object())
+        self.assertEqual(func(c_void_p(42)), 42)
+
+        class Adapter:
+            def from_param(cls, obj):
+                raise ValueError(obj)
+
+        func.argtypes = (Adapter(),)
+        # ArgumentError: argument 1: ValueError: 99
+        self.assertRaises(ArgumentError, func, 99)
+
+    def test_abstract(self):
+        from ctypes import (Array, Structure, Union, _Pointer,
+                            _SimpleCData, _CFuncPtr)
+
+        self.assertRaises(TypeError, Array.from_param, 42)
+        self.assertRaises(TypeError, Structure.from_param, 42)
+        self.assertRaises(TypeError, Union.from_param, 42)
+        self.assertRaises(TypeError, _CFuncPtr.from_param, 42)
+        self.assertRaises(TypeError, _Pointer.from_param, 42)
+        self.assertRaises(TypeError, _SimpleCData.from_param, 42)
+
+    @test.support.cpython_only
+    def test_issue31311(self):
+        # __setstate__ should neither raise a SystemError nor crash in case
+        # of a bad __dict__.
+        from ctypes import Structure
+
+        class BadStruct(Structure):
+            @property
+            def __dict__(self):
+                pass
+        with self.assertRaises(TypeError):
+            BadStruct().__setstate__({}, b'foo')
+
+        class WorseStruct(Structure):
+            @property
+            def __dict__(self):
+                1/0
+        with self.assertRaises(ZeroDivisionError):
+            WorseStruct().__setstate__({}, b'foo')
+
+    def test_parameter_repr(self):
+        from ctypes import (
+            c_bool,
+            c_char,
+            c_wchar,
+            c_byte,
+            c_ubyte,
+            c_short,
+            c_ushort,
+            c_int,
+            c_uint,
+            c_long,
+            c_ulong,
+            c_longlong,
+            c_ulonglong,
+            c_float,
+            c_double,
+            c_longdouble,
+            c_char_p,
+            c_wchar_p,
+            c_void_p,
+        )
+        self.assertRegex(repr(c_bool.from_param(True)), r"^<cparam '\?' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_char.from_param(97)), "<cparam 'c' ('a')>")
+        self.assertRegex(repr(c_wchar.from_param('a')), r"^<cparam 'u' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_byte.from_param(98)), "<cparam 'b' (98)>")
+        self.assertEqual(repr(c_ubyte.from_param(98)), "<cparam 'B' (98)>")
+        self.assertEqual(repr(c_short.from_param(511)), "<cparam 'h' (511)>")
+        self.assertEqual(repr(c_ushort.from_param(511)), "<cparam 'H' (511)>")
+        self.assertRegex(repr(c_int.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_uint.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_long.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_ulong.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_longlong.from_param(20000)), r"^<cparam '[liq]' \(20000\)>$")
+        self.assertRegex(repr(c_ulonglong.from_param(20000)), r"^<cparam '[LIQ]' \(20000\)>$")
+        self.assertEqual(repr(c_float.from_param(1.5)), "<cparam 'f' (1.5)>")
+        self.assertEqual(repr(c_double.from_param(1.5)), "<cparam 'd' (1.5)>")
+        self.assertEqual(repr(c_double.from_param(1e300)), "<cparam 'd' (1e+300)>")
+        self.assertRegex(repr(c_longdouble.from_param(1.5)), r"^<cparam ('d' \(1.5\)|'g' at 0x[A-Fa-f0-9]+)>$")
+        self.assertRegex(repr(c_char_p.from_param(b'hihi')), r"^<cparam 'z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_wchar_p.from_param('hihi')), r"^<cparam 'Z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_void_p.from_param(0x12)), r"^<cparam 'P' \(0x0*12\)>$")
+
+    @test.support.cpython_only
+    def test_from_param_result_refcount(self):
+        # Issue #99952
+        import _ctypes_test
+        from ctypes import PyDLL, c_int, c_void_p, py_object, Structure
+
+        class X(Structure):
+            """This struct size is <= sizeof(void*)."""
+            _fields_ = [("a", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, X]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+        class Y(Structure):
+            """This struct size is > sizeof(void*)."""
+            _fields_ = [("a", c_void_p), ("b", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, Y]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+################################################################
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pep3118.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pep3118.py
new file mode 100644
index 0000000..efffc80
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pep3118.py
@@ -0,0 +1,235 @@
+import unittest
+from ctypes import *
+import re, sys
+
+if sys.byteorder == "little":
+    THIS_ENDIAN = "<"
+    OTHER_ENDIAN = ">"
+else:
+    THIS_ENDIAN = ">"
+    OTHER_ENDIAN = "<"
+
+def normalize(format):
+    # Remove current endian specifier and white space from a format
+    # string
+    if format is None:
+        return ""
+    format = format.replace(OTHER_ENDIAN, THIS_ENDIAN)
+    return re.sub(r"\s", "", format)
+
+class Test(unittest.TestCase):
+
+    def test_native_types(self):
+        for tp, fmt, shape, itemtp in native_types:
+            ob = tp()
+            v = memoryview(ob)
+            try:
+                self.assertEqual(normalize(v.format), normalize(fmt))
+                if shape:
+                    self.assertEqual(len(v), shape[0])
+                else:
+                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
+                self.assertEqual(v.itemsize, sizeof(itemtp))
+                self.assertEqual(v.shape, shape)
+                # XXX Issue #12851: PyCData_NewGetBuffer() must provide strides
+                #     if requested. memoryview currently reconstructs missing
+                #     stride information, so this assert will fail.
+                # self.assertEqual(v.strides, ())
+
+                # they are always read/write
+                self.assertFalse(v.readonly)
+
+                if v.shape:
+                    n = 1
+                    for dim in v.shape:
+                        n = n * dim
+                    self.assertEqual(n * v.itemsize, len(v.tobytes()))
+            except:
+                # so that we can see the failing type
+                print(tp)
+                raise
+
+    def test_endian_types(self):
+        for tp, fmt, shape, itemtp in endian_types:
+            ob = tp()
+            v = memoryview(ob)
+            try:
+                self.assertEqual(v.format, fmt)
+                if shape:
+                    self.assertEqual(len(v), shape[0])
+                else:
+                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
+                self.assertEqual(v.itemsize, sizeof(itemtp))
+                self.assertEqual(v.shape, shape)
+                # XXX Issue #12851
+                # self.assertEqual(v.strides, ())
+
+                # they are always read/write
+                self.assertFalse(v.readonly)
+
+                if v.shape:
+                    n = 1
+                    for dim in v.shape:
+                        n = n * dim
+                    self.assertEqual(n, len(v))
+            except:
+                # so that we can see the failing type
+                print(tp)
+                raise
+
+# define some structure classes
+
+class Point(Structure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class PackedPoint(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class Point2(Structure):
+    pass
+Point2._fields_ = [("x", c_long), ("y", c_long)]
+
+class EmptyStruct(Structure):
+    _fields_ = []
+
+class aUnion(Union):
+    _fields_ = [("a", c_int)]
+
+class StructWithArrays(Structure):
+    _fields_ = [("x", c_long * 3 * 2), ("y", Point * 4)]
+
+class Incomplete(Structure):
+    pass
+
+class Complete(Structure):
+    pass
+PComplete = POINTER(Complete)
+Complete._fields_ = [("a", c_long)]
+
+################################################################
+#
+# This table contains format strings as they look on little endian
+# machines.  The test replaces '<' with '>' on big endian machines.
+#
+
+# Platform-specific type codes
+s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
+s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
+s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
+s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
+s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
+s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
+s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
+s_longlong = "q"
+s_ulonglong = "Q"
+s_float = "f"
+s_double = "d"
+s_longdouble = "g"
+
+# Alias definitions in ctypes/__init__.py
+if c_int is c_long:
+    s_int = s_long
+if c_uint is c_ulong:
+    s_uint = s_ulong
+if c_longlong is c_long:
+    s_longlong = s_long
+if c_ulonglong is c_ulong:
+    s_ulonglong = s_ulong
+if c_longdouble is c_double:
+    s_longdouble = s_double
+
+
+native_types = [
+    # type                      format                  shape           calc itemsize
+
+    ## simple types
+
+    (c_char,                    "<c",                   (),           c_char),
+    (c_byte,                    "<b",                   (),           c_byte),
+    (c_ubyte,                   "<B",                   (),           c_ubyte),
+    (c_short,                   "<" + s_short,          (),           c_short),
+    (c_ushort,                  "<" + s_ushort,         (),           c_ushort),
+
+    (c_int,                     "<" + s_int,            (),           c_int),
+    (c_uint,                    "<" + s_uint,           (),           c_uint),
+
+    (c_long,                    "<" + s_long,           (),           c_long),
+    (c_ulong,                   "<" + s_ulong,          (),           c_ulong),
+
+    (c_longlong,                "<" + s_longlong,       (),           c_longlong),
+    (c_ulonglong,               "<" + s_ulonglong,      (),           c_ulonglong),
+
+    (c_float,                   "<f",                   (),           c_float),
+    (c_double,                  "<d",                   (),           c_double),
+
+    (c_longdouble,              "<" + s_longdouble,     (),           c_longdouble),
+
+    (c_bool,                    "<" + s_bool,           (),           c_bool),
+    (py_object,                 "<O",                   (),           py_object),
+
+    ## pointers
+
+    (POINTER(c_byte),           "&<b",                  (),           POINTER(c_byte)),
+    (POINTER(POINTER(c_long)),  "&&<" + s_long,         (),           POINTER(POINTER(c_long))),
+
+    ## arrays and pointers
+
+    (c_double * 4,              "<d",                   (4,),           c_double),
+    (c_double * 0,              "<d",                   (0,),           c_double),
+    (c_float * 4 * 3 * 2,       "<f",                   (2,3,4),        c_float),
+    (c_float * 4 * 0 * 2,       "<f",                   (2,0,4),        c_float),
+    (POINTER(c_short) * 2,      "&<" + s_short,         (2,),           POINTER(c_short)),
+    (POINTER(c_short) * 2 * 3,  "&<" + s_short,         (3,2,),         POINTER(c_short)),
+    (POINTER(c_short * 2),      "&(2)<" + s_short,      (),             POINTER(c_short)),
+
+    ## structures and unions
+
+    (Point,                     "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point),
+    # packed structures do not implement the pep
+    (PackedPoint,               "B",                                   (),  PackedPoint),
+    (Point2,                    "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point2),
+    (EmptyStruct,               "T{}",                                 (),  EmptyStruct),
+    # the pep doesn't support unions
+    (aUnion,                    "B",                                   (),  aUnion),
+    # structure with sub-arrays
+    (StructWithArrays, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (), StructWithArrays),
+    (StructWithArrays * 3, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (3,), StructWithArrays),
+
+    ## pointer to incomplete structure
+    (Incomplete,                "B",                    (),           Incomplete),
+    (POINTER(Incomplete),       "&B",                   (),           POINTER(Incomplete)),
+
+    # 'Complete' is a structure that starts incomplete, but is completed after the
+    # pointer type to it has been created.
+    (Complete,                  "T{<l:a:}".replace('l', s_long), (), Complete),
+    # Unfortunately the pointer format string is not fixed...
+    (POINTER(Complete),         "&B",                   (),           POINTER(Complete)),
+
+    ## other
+
+    # function signatures are not implemented
+    (CFUNCTYPE(None),           "X{}",                  (),           CFUNCTYPE(None)),
+
+    ]
+
+class BEPoint(BigEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class LEPoint(LittleEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+################################################################
+#
+# This table contains format strings as they really look, on both big
+# and little endian machines.
+#
+endian_types = [
+    (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
+    (LEPoint, "T{<l:x:<l:y:}".replace('l', s_long), (), LEPoint),
+    (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
+    (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
+    ]
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pickling.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pickling.py
new file mode 100644
index 0000000..c4a79b9
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pickling.py
@@ -0,0 +1,81 @@
+import unittest
+import pickle
+from ctypes import *
+import _ctypes_test
+dll = CDLL(_ctypes_test.__file__)
+
+class X(Structure):
+    _fields_ = [("a", c_int), ("b", c_double)]
+    init_called = 0
+    def __init__(self, *args, **kw):
+        X.init_called += 1
+        self.x = 42
+
+class Y(X):
+    _fields_ = [("str", c_char_p)]
+
+class PickleTest:
+    def dumps(self, item):
+        return pickle.dumps(item, self.proto)
+
+    def loads(self, item):
+        return pickle.loads(item)
+
+    def test_simple(self):
+        for src in [
+            c_int(42),
+            c_double(3.14),
+            ]:
+            dst = self.loads(self.dumps(src))
+            self.assertEqual(src.__dict__, dst.__dict__)
+            self.assertEqual(memoryview(src).tobytes(),
+                                 memoryview(dst).tobytes())
+
+    def test_struct(self):
+        X.init_called = 0
+
+        x = X()
+        x.a = 42
+        self.assertEqual(X.init_called, 1)
+
+        y = self.loads(self.dumps(x))
+
+        # loads must NOT call __init__
+        self.assertEqual(X.init_called, 1)
+
+        # ctypes instances are identical when the instance __dict__
+        # and the memory buffer are identical
+        self.assertEqual(y.__dict__, x.__dict__)
+        self.assertEqual(memoryview(y).tobytes(),
+                             memoryview(x).tobytes())
+
+    def test_unpickable(self):
+        # ctypes objects that are pointers or contain pointers are
+        # unpickable.
+        self.assertRaises(ValueError, lambda: self.dumps(Y()))
+
+        prototype = CFUNCTYPE(c_int)
+
+        for item in [
+            c_char_p(),
+            c_wchar_p(),
+            c_void_p(),
+            pointer(c_int(42)),
+            dll._testfunc_p_p,
+            prototype(lambda: 42),
+            ]:
+            self.assertRaises(ValueError, lambda: self.dumps(item))
+
+    def test_wchar(self):
+        self.dumps(c_char(b"x"))
+        # Issue 5049
+        self.dumps(c_wchar("x"))
+
+for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+    name = 'PickleTest_%s' % proto
+    globals()[name] = type(name,
+                           (PickleTest, unittest.TestCase),
+                           {'proto': proto})
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pointers.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pointers.py
new file mode 100644
index 0000000..e975158
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_pointers.py
@@ -0,0 +1,223 @@
+import unittest, sys
+
+from ctypes import *
+import _ctypes_test
+
+ctype_types = [c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                 c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_float]
+python_types = [int, int, int, int, int, int,
+                int, int, int, int, float, float]
+
+class PointersTestCase(unittest.TestCase):
+
+    def test_pointer_crash(self):
+
+        class A(POINTER(c_ulong)):
+            pass
+
+        POINTER(c_ulong)(c_ulong(22))
+        # Pointer can't set contents: has no _type_
+        self.assertRaises(TypeError, A, c_ulong(33))
+
+    def test_pass_pointers(self):
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_p_p
+        if sizeof(c_longlong) == sizeof(c_void_p):
+            func.restype = c_longlong
+        else:
+            func.restype = c_long
+
+        i = c_int(12345678)
+##        func.argtypes = (POINTER(c_int),)
+        address = func(byref(i))
+        self.assertEqual(c_int.from_address(address).value, 12345678)
+
+        func.restype = POINTER(c_int)
+        res = func(pointer(i))
+        self.assertEqual(res.contents.value, 12345678)
+        self.assertEqual(res[0], 12345678)
+
+    def test_change_pointers(self):
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_p_p
+
+        i = c_int(87654)
+        func.restype = POINTER(c_int)
+        func.argtypes = (POINTER(c_int),)
+
+        res = func(pointer(i))
+        self.assertEqual(res[0], 87654)
+        self.assertEqual(res.contents.value, 87654)
+
+        # C code: *res = 54345
+        res[0] = 54345
+        self.assertEqual(i.value, 54345)
+
+        # C code:
+        #   int x = 12321;
+        #   res = &x
+        x = c_int(12321)
+        res.contents = x
+        self.assertEqual(i.value, 54345)
+
+        x.value = -99
+        self.assertEqual(res.contents.value, -99)
+
+    def test_callbacks_with_pointers(self):
+        # a function type receiving a pointer
+        PROTOTYPE = CFUNCTYPE(c_int, POINTER(c_int))
+
+        self.result = []
+
+        def func(arg):
+            for i in range(10):
+##                print arg[i],
+                self.result.append(arg[i])
+##            print
+            return 0
+        callback = PROTOTYPE(func)
+
+        dll = CDLL(_ctypes_test.__file__)
+        # This function expects a function pointer,
+        # and calls this with an integer pointer as parameter.
+        # The int pointer points to a table containing the numbers 1..10
+        doit = dll._testfunc_callback_with_pointer
+
+##        i = c_int(42)
+##        callback(byref(i))
+##        self.assertEqual(i.value, 84)
+
+        doit(callback)
+##        print self.result
+        doit(callback)
+##        print self.result
+
+    def test_basics(self):
+        from operator import delitem
+        for ct, pt in zip(ctype_types, python_types):
+            i = ct(42)
+            p = pointer(i)
+##            print type(p.contents), ct
+            self.assertIs(type(p.contents), ct)
+            # p.contents is the same as p[0]
+##            print p.contents
+##            self.assertEqual(p.contents, 42)
+##            self.assertEqual(p[0], 42)
+
+            self.assertRaises(TypeError, delitem, p, 0)
+
+    def test_from_address(self):
+        from array import array
+        a = array('i', [100, 200, 300, 400, 500])
+        addr = a.buffer_info()[0]
+
+        p = POINTER(POINTER(c_int))
+##        print dir(p)
+##        print p.from_address
+##        print p.from_address(addr)[0][0]
+
+    def test_other(self):
+        class Table(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int)]
+
+        pt = pointer(Table(1, 2, 3))
+
+        self.assertEqual(pt.contents.a, 1)
+        self.assertEqual(pt.contents.b, 2)
+        self.assertEqual(pt.contents.c, 3)
+
+        pt.contents.c = 33
+
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[Table]
+
+    def test_basic(self):
+        p = pointer(c_int(42))
+        # Although a pointer can be indexed, it has no length
+        self.assertRaises(TypeError, len, p)
+        self.assertEqual(p[0], 42)
+        self.assertEqual(p[0:1], [42])
+        self.assertEqual(p.contents.value, 42)
+
+    def test_charpp(self):
+        """Test that a character pointer-to-pointer is correctly passed"""
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_c_p_p
+        func.restype = c_char_p
+        argv = (c_char_p * 2)()
+        argc = c_int( 2 )
+        argv[0] = b'hello'
+        argv[1] = b'world'
+        result = func( byref(argc), argv )
+        self.assertEqual(result, b'world')
+
+    def test_bug_1467852(self):
+        # http://sourceforge.net/tracker/?func=detail&atid=532154&aid=1467852&group_id=71702
+        x = c_int(5)
+        dummy = []
+        for i in range(32000):
+            dummy.append(c_int(i))
+        y = c_int(6)
+        p = pointer(x)
+        pp = pointer(p)
+        q = pointer(y)
+        pp[0] = q         # <==
+        self.assertEqual(p[0], 6)
+    def test_c_void_p(self):
+        # http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470
+        if sizeof(c_void_p) == 4:
+            self.assertEqual(c_void_p(0xFFFFFFFF).value,
+                                 c_void_p(-1).value)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+        elif sizeof(c_void_p) == 8:
+            self.assertEqual(c_void_p(0xFFFFFFFF).value,
+                                 0xFFFFFFFF)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+
+        self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted
+        self.assertRaises(TypeError, c_void_p, object()) # nor other objects
+
+    def test_pointers_bool(self):
+        # NULL pointers have a boolean False value, non-NULL pointers True.
+        self.assertEqual(bool(POINTER(c_int)()), False)
+        self.assertEqual(bool(pointer(c_int())), True)
+
+        self.assertEqual(bool(CFUNCTYPE(None)(0)), False)
+        self.assertEqual(bool(CFUNCTYPE(None)(42)), True)
+
+        # COM methods are boolean True:
+        if sys.platform == "win32":
+            mth = WINFUNCTYPE(None)(42, "name", (), None)
+            self.assertEqual(bool(mth), True)
+
+    def test_pointer_type_name(self):
+        LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
+        self.assertTrue(POINTER(LargeNamedType))
+
+        # to not leak references, we must clean _pointer_type_cache
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[LargeNamedType]
+
+    def test_pointer_type_str_name(self):
+        large_string = 'T' * 2 ** 25
+        P = POINTER(large_string)
+        self.assertTrue(P)
+
+        # to not leak references, we must clean _pointer_type_cache
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[id(P)]
+
+    def test_abstract(self):
+        from ctypes import _Pointer
+
+        self.assertRaises(TypeError, _Pointer.set_type, 42)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_prototypes.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_prototypes.py
new file mode 100644
index 0000000..cd0c649
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_prototypes.py
@@ -0,0 +1,222 @@
+from ctypes import *
+from ctypes.test import need_symbol
+import unittest
+
+# IMPORTANT INFO:
+#
+# Consider this call:
+#    func.restype = c_char_p
+#    func(c_char_p("123"))
+# It returns
+#    "123"
+#
+# WHY IS THIS SO?
+#
+# argument tuple (c_char_p("123"), ) is destroyed after the function
+# func is called, but NOT before the result is actually built.
+#
+# If the arglist would be destroyed BEFORE the result has been built,
+# the c_char_p("123") object would already have a zero refcount,
+# and the pointer passed to (and returned by) the function would
+# probably point to deallocated space.
+#
+# In this case, there would have to be an additional reference to the argument...
+
+import _ctypes_test
+testdll = CDLL(_ctypes_test.__file__)
+
+# Return machine address `a` as a (possibly long) non-negative integer.
+# Starting with Python 2.5, id(anything) is always non-negative, and
+# the ctypes addressof() inherits that via PyLong_FromVoidPtr().
+def positive_address(a):
+    if a >= 0:
+        return a
+    # View the bits in `a` as unsigned instead.
+    import struct
+    num_bits = struct.calcsize("P") * 8 # num bits in native machine address
+    a += 1 << num_bits
+    assert a >= 0
+    return a
+
+def c_wbuffer(init):
+    n = len(init) + 1
+    return (c_wchar * n)(*init)
+
+class CharPointersTestCase(unittest.TestCase):
+
+    def setUp(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_long
+        func.argtypes = None
+
+    def test_paramflags(self):
+        # function returns c_void_p result,
+        # and has a required parameter named 'input'
+        prototype = CFUNCTYPE(c_void_p, c_void_p)
+        func = prototype(("_testfunc_p_p", testdll),
+                         ((1, "input"),))
+
+        try:
+            func()
+        except TypeError as details:
+            self.assertEqual(str(details), "required argument 'input' missing")
+        else:
+            self.fail("TypeError not raised")
+
+        self.assertEqual(func(None), None)
+        self.assertEqual(func(input=None), None)
+
+
+    def test_int_pointer_arg(self):
+        func = testdll._testfunc_p_p
+        if sizeof(c_longlong) == sizeof(c_void_p):
+            func.restype = c_longlong
+        else:
+            func.restype = c_long
+        self.assertEqual(0, func(0))
+
+        ci = c_int(0)
+
+        func.argtypes = POINTER(c_int),
+        self.assertEqual(positive_address(addressof(ci)),
+                             positive_address(func(byref(ci))))
+
+        func.argtypes = c_char_p,
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+        func.argtypes = POINTER(c_short),
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+        func.argtypes = POINTER(c_double),
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+    def test_POINTER_c_char_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = POINTER(c_char),
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(None, func(c_char_p(None)))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+
+        self.assertEqual(b"123", func(c_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+    def test_c_char_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = c_char_p,
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(None, func(c_char_p(None)))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+
+        self.assertEqual(b"123", func(c_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+    def test_c_void_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = c_void_p,
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+        self.assertEqual(None, func(c_char_p(None)))
+
+        self.assertEqual(b"123", func(c_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+        func(byref(c_int()))
+        func(pointer(c_int()))
+        func((c_int * 3)())
+
+    @need_symbol('c_wchar_p')
+    def test_c_void_p_arg_with_c_wchar_p(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = c_void_p,
+
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+    def test_instance(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_void_p
+
+        class X:
+            _as_parameter_ = None
+
+        func.argtypes = c_void_p,
+        self.assertEqual(None, func(X()))
+
+        func.argtypes = None
+        self.assertEqual(None, func(X()))
+
+@need_symbol('c_wchar')
+class WCharPointersTestCase(unittest.TestCase):
+
+    def setUp(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_int
+        func.argtypes = None
+
+
+    def test_POINTER_c_wchar_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = POINTER(c_wchar),
+
+        self.assertEqual(None, func(None))
+        self.assertEqual("123", func("123"))
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+        self.assertEqual("123", func(c_wbuffer("123")))
+        ca = c_wchar("a")
+        self.assertEqual("a", func(pointer(ca))[0])
+        self.assertEqual("a", func(byref(ca))[0])
+
+    def test_c_wchar_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = c_wchar_p,
+
+        c_wchar_p.from_param("123")
+
+        self.assertEqual(None, func(None))
+        self.assertEqual("123", func("123"))
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+        # XXX Currently, these raise TypeErrors, although they shouldn't:
+        self.assertEqual("123", func(c_wbuffer("123")))
+        ca = c_wchar("a")
+        self.assertEqual("a", func(pointer(ca))[0])
+        self.assertEqual("a", func(byref(ca))[0])
+
+class ArrayTest(unittest.TestCase):
+    def test(self):
+        func = testdll._testfunc_ai8
+        func.restype = POINTER(c_int)
+        func.argtypes = c_int * 8,
+
+        func((c_int * 8)(1, 2, 3, 4, 5, 6, 7, 8))
+
+        # This did crash before:
+
+        def func(): pass
+        CFUNCTYPE(None, c_int * 3)(func)
+
+################################################################
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_python_api.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_python_api.py
new file mode 100644
index 0000000..49571f9
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_python_api.py
@@ -0,0 +1,85 @@
+from ctypes import *
+import unittest
+from test import support
+
+################################################################
+# This section should be moved into ctypes\__init__.py, when it's ready.
+
+from _ctypes import PyObj_FromPtr
+
+################################################################
+
+from sys import getrefcount as grc
+
+class PythonAPITestCase(unittest.TestCase):
+
+    def test_PyBytes_FromStringAndSize(self):
+        PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
+
+        PyBytes_FromStringAndSize.restype = py_object
+        PyBytes_FromStringAndSize.argtypes = c_char_p, c_size_t
+
+        self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
+
+    @support.refcount_test
+    def test_PyString_FromString(self):
+        pythonapi.PyBytes_FromString.restype = py_object
+        pythonapi.PyBytes_FromString.argtypes = (c_char_p,)
+
+        s = b"abc"
+        refcnt = grc(s)
+        pyob = pythonapi.PyBytes_FromString(s)
+        self.assertEqual(grc(s), refcnt)
+        self.assertEqual(s, pyob)
+        del pyob
+        self.assertEqual(grc(s), refcnt)
+
+    @support.refcount_test
+    def test_PyLong_Long(self):
+        ref42 = grc(42)
+        pythonapi.PyLong_FromLong.restype = py_object
+        self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
+
+        self.assertEqual(grc(42), ref42)
+
+        pythonapi.PyLong_AsLong.argtypes = (py_object,)
+        pythonapi.PyLong_AsLong.restype = c_long
+
+        res = pythonapi.PyLong_AsLong(42)
+        self.assertEqual(grc(res), ref42 + 1)
+        del res
+        self.assertEqual(grc(42), ref42)
+
+    @support.refcount_test
+    def test_PyObj_FromPtr(self):
+        s = "abc def ghi jkl"
+        ref = grc(s)
+        # id(python-object) is the address
+        pyobj = PyObj_FromPtr(id(s))
+        self.assertIs(s, pyobj)
+
+        self.assertEqual(grc(s), ref + 1)
+        del pyobj
+        self.assertEqual(grc(s), ref)
+
+    def test_PyOS_snprintf(self):
+        PyOS_snprintf = pythonapi.PyOS_snprintf
+        PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
+
+        buf = c_buffer(256)
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s", b"ctypes")
+        self.assertEqual(buf.value, b"Hello from ctypes")
+
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
+        self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
+
+        # not enough arguments
+        self.assertRaises(TypeError, PyOS_snprintf, buf)
+
+    def test_pyobject_repr(self):
+        self.assertEqual(repr(py_object()), "py_object(<NULL>)")
+        self.assertEqual(repr(py_object(42)), "py_object(42)")
+        self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_random_things.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_random_things.py
new file mode 100644
index 0000000..2988e27
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_random_things.py
@@ -0,0 +1,77 @@
+from ctypes import *
+import contextlib
+from test import support
+import unittest
+import sys
+
+
+def callback_func(arg):
+    42 / arg
+    raise ValueError(arg)
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class call_function_TestCase(unittest.TestCase):
+    # _ctypes.call_function is deprecated and private, but used by
+    # Gary Bishp's readline module.  If we have it, we must test it as well.
+
+    def test(self):
+        from _ctypes import call_function
+        windll.kernel32.LoadLibraryA.restype = c_void_p
+        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        windll.kernel32.GetProcAddress.restype = c_void_p
+
+        hdll = windll.kernel32.LoadLibraryA(b"kernel32")
+        funcaddr = windll.kernel32.GetProcAddress(hdll, b"GetModuleHandleA")
+
+        self.assertEqual(call_function(funcaddr, (None,)),
+                             windll.kernel32.GetModuleHandleA(None))
+
+class CallbackTracbackTestCase(unittest.TestCase):
+    # When an exception is raised in a ctypes callback function, the C
+    # code prints a traceback.
+    #
+    # This test makes sure the exception types *and* the exception
+    # value is printed correctly.
+    #
+    # Changed in 0.9.3: No longer is '(in callback)' prepended to the
+    # error message - instead an additional frame for the C code is
+    # created, then a full traceback printed.  When SystemExit is
+    # raised in a callback function, the interpreter exits.
+
+    @contextlib.contextmanager
+    def expect_unraisable(self, exc_type, exc_msg=None):
+        with support.catch_unraisable_exception() as cm:
+            yield
+
+            self.assertIsInstance(cm.unraisable.exc_value, exc_type)
+            if exc_msg is not None:
+                self.assertEqual(str(cm.unraisable.exc_value), exc_msg)
+            self.assertEqual(cm.unraisable.err_msg,
+                             "Exception ignored on calling ctypes "
+                             "callback function")
+            self.assertIs(cm.unraisable.object, callback_func)
+
+    def test_ValueError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ValueError, '42'):
+            cb(42)
+
+    def test_IntegerDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0)
+
+    def test_FloatDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_double)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0.0)
+
+    def test_TypeErrorDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
+        err_msg = "unsupported operand type(s) for /: 'int' and 'bytes'"
+        with self.expect_unraisable(TypeError, err_msg):
+            cb(b"spam")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_refcounts.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_refcounts.py
new file mode 100644
index 0000000..48958cd
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_refcounts.py
@@ -0,0 +1,116 @@
+import unittest
+from test import support
+import ctypes
+import gc
+
+MyCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
+OtherCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulonglong)
+
+import _ctypes_test
+dll = ctypes.CDLL(_ctypes_test.__file__)
+
+class RefcountTestCase(unittest.TestCase):
+
+    @support.refcount_test
+    def test_1(self):
+        from sys import getrefcount as grc
+
+        f = dll._testfunc_callback_i_if
+        f.restype = ctypes.c_int
+        f.argtypes = [ctypes.c_int, MyCallback]
+
+        def callback(value):
+            #print "called back with", value
+            return value
+
+        self.assertEqual(grc(callback), 2)
+        cb = MyCallback(callback)
+
+        self.assertGreater(grc(callback), 2)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+        cb = None
+
+        gc.collect()
+
+        self.assertEqual(grc(callback), 2)
+
+
+    @support.refcount_test
+    def test_refcount(self):
+        from sys import getrefcount as grc
+        def func(*args):
+            pass
+        # this is the standard refcount for func
+        self.assertEqual(grc(func), 2)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        f = OtherCallback(func)
+        self.assertGreater(grc(func), 2)
+
+        # and may release it again
+        del f
+        self.assertGreaterEqual(grc(func), 2)
+
+        # but now it must be gone
+        gc.collect()
+        self.assertEqual(grc(func), 2)
+
+        class X(ctypes.Structure):
+            _fields_ = [("a", OtherCallback)]
+        x = X()
+        x.a = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(grc(func), 2)
+
+        # and may release it again
+        del x
+        self.assertGreaterEqual(grc(func), 2)
+
+        # and now it must be gone again
+        gc.collect()
+        self.assertEqual(grc(func), 2)
+
+        f = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(grc(func), 2)
+
+        # create a cycle
+        f.cycle = f
+
+        del f
+        gc.collect()
+        self.assertEqual(grc(func), 2)
+
+class AnotherLeak(unittest.TestCase):
+    def test_callback(self):
+        import sys
+
+        proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
+        def func(a, b):
+            return a * b * 2
+        f = proto(func)
+
+        a = sys.getrefcount(ctypes.c_int)
+        f(1, 2)
+        self.assertEqual(sys.getrefcount(ctypes.c_int), a)
+
+    @support.refcount_test
+    def test_callback_py_object_none_return(self):
+        # bpo-36880: test that returning None from a py_object callback
+        # does not decrement the refcount of None.
+
+        for FUNCTYPE in (ctypes.CFUNCTYPE, ctypes.PYFUNCTYPE):
+            with self.subTest(FUNCTYPE=FUNCTYPE):
+                @FUNCTYPE(ctypes.py_object)
+                def func():
+                    return None
+
+                # Check that calling func does not affect None's refcount.
+                for _ in range(10000):
+                    func()
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_repr.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_repr.py
new file mode 100644
index 0000000..60a2c80
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_repr.py
@@ -0,0 +1,29 @@
+from ctypes import *
+import unittest
+
+subclasses = []
+for base in [c_byte, c_short, c_int, c_long, c_longlong,
+        c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong,
+        c_float, c_double, c_longdouble, c_bool]:
+    class X(base):
+        pass
+    subclasses.append(X)
+
+class X(c_char):
+    pass
+
+# This test checks if the __repr__ is correct for subclasses of simple types
+
+class ReprTest(unittest.TestCase):
+    def test_numbers(self):
+        for typ in subclasses:
+            base = typ.__bases__[0]
+            self.assertTrue(repr(base(42)).startswith(base.__name__))
+            self.assertEqual("<X object at", repr(typ(42))[:12])
+
+    def test_char(self):
+        self.assertEqual("c_char(b'x')", repr(c_char(b'x')))
+        self.assertEqual("<X object at", repr(X(b'x'))[:12])
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_returnfuncptrs.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_returnfuncptrs.py
new file mode 100644
index 0000000..1974f40
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_returnfuncptrs.py
@@ -0,0 +1,66 @@
+import unittest
+from ctypes import *
+
+import _ctypes_test
+
+class ReturnFuncPtrTestCase(unittest.TestCase):
+
+    def test_with_prototype(self):
+        # The _ctypes_test shared lib/dll exports quite some functions for testing.
+        # The get_strchr function returns a *pointer* to the C strchr function.
+        dll = CDLL(_ctypes_test.__file__)
+        get_strchr = dll.get_strchr
+        get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char)
+        strchr = get_strchr()
+        self.assertEqual(strchr(b"abcdef", b"b"), b"bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertEqual(strchr(b"abcdef", 98), b"bcdef")
+        self.assertEqual(strchr(b"abcdef", 107), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    def test_without_prototype(self):
+        dll = CDLL(_ctypes_test.__file__)
+        get_strchr = dll.get_strchr
+        # the default 'c_int' would not work on systems where sizeof(int) != sizeof(void *)
+        get_strchr.restype = c_void_p
+        addr = get_strchr()
+        # _CFuncPtr instances are now callable with an integer argument
+        # which denotes a function address:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr)
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    def test_from_dll(self):
+        dll = CDLL(_ctypes_test.__file__)
+        # _CFuncPtr instances are now callable with a tuple argument
+        # which denotes a function name and a dll:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(("my_strchr", dll))
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    # Issue 6083: Reference counting bug
+    def test_from_dll_refcount(self):
+        class BadSequence(tuple):
+            def __getitem__(self, key):
+                if key == 0:
+                    return "my_strchr"
+                if key == 1:
+                    return CDLL(_ctypes_test.__file__)
+                raise IndexError
+
+        # _CFuncPtr instances are now callable with a tuple argument
+        # which denotes a function name and a dll:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(
+                BadSequence(("my_strchr", CDLL(_ctypes_test.__file__))))
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_simplesubclasses.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_simplesubclasses.py
new file mode 100644
index 0000000..3da2794
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_simplesubclasses.py
@@ -0,0 +1,55 @@
+import unittest
+from ctypes import *
+
+class MyInt(c_int):
+    def __eq__(self, other):
+        if type(other) != MyInt:
+            return NotImplementedError
+        return self.value == other.value
+
+class Test(unittest.TestCase):
+
+    def test_compare(self):
+        self.assertEqual(MyInt(3), MyInt(3))
+        self.assertNotEqual(MyInt(42), MyInt(43))
+
+    def test_ignore_retval(self):
+        # Test if the return value of a callback is ignored
+        # if restype is None
+        proto = CFUNCTYPE(None)
+        def func():
+            return (1, "abc", None)
+
+        cb = proto(func)
+        self.assertEqual(None, cb())
+
+
+    def test_int_callback(self):
+        args = []
+        def func(arg):
+            args.append(arg)
+            return arg
+
+        cb = CFUNCTYPE(None, MyInt)(func)
+
+        self.assertEqual(None, cb(42))
+        self.assertEqual(type(args[-1]), MyInt)
+
+        cb = CFUNCTYPE(c_int, c_int)(func)
+
+        self.assertEqual(42, cb(42))
+        self.assertEqual(type(args[-1]), int)
+
+    def test_int_struct(self):
+        class X(Structure):
+            _fields_ = [("x", MyInt)]
+
+        self.assertEqual(X().x, MyInt())
+
+        s = X()
+        s.x = MyInt(42)
+
+        self.assertEqual(s.x, MyInt(42))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_sizes.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_sizes.py
new file mode 100644
index 0000000..4ceacbc
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_sizes.py
@@ -0,0 +1,33 @@
+# Test specifically-sized containers.
+
+from ctypes import *
+
+import unittest
+
+
+class SizesTestCase(unittest.TestCase):
+    def test_8(self):
+        self.assertEqual(1, sizeof(c_int8))
+        self.assertEqual(1, sizeof(c_uint8))
+
+    def test_16(self):
+        self.assertEqual(2, sizeof(c_int16))
+        self.assertEqual(2, sizeof(c_uint16))
+
+    def test_32(self):
+        self.assertEqual(4, sizeof(c_int32))
+        self.assertEqual(4, sizeof(c_uint32))
+
+    def test_64(self):
+        self.assertEqual(8, sizeof(c_int64))
+        self.assertEqual(8, sizeof(c_uint64))
+
+    def test_size_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
+
+    def test_ssize_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_ssize_t))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_slicing.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_slicing.py
new file mode 100644
index 0000000..a3932f1
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_slicing.py
@@ -0,0 +1,167 @@
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+
+import _ctypes_test
+
+class SlicesTestCase(unittest.TestCase):
+    def test_getslice_cint(self):
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
+        self.assertEqual(a[0:2], b[0:2])
+        self.assertEqual(a[0:2:], b[0:2:])
+        self.assertEqual(len(a), len(b))
+        self.assertEqual(a[5:7], b[5:7])
+        self.assertEqual(a[5:7:], b[5:7:])
+        self.assertEqual(a[-1], b[-1])
+        self.assertEqual(a[:], b[:])
+        self.assertEqual(a[::], b[::])
+        self.assertEqual(a[10::-1], b[10::-1])
+        self.assertEqual(a[30:20:-1], b[30:20:-1])
+        self.assertEqual(a[:12:6], b[:12:6])
+        self.assertEqual(a[2:6:4], b[2:6:4])
+
+        a[0:5] = range(5, 10)
+        self.assertEqual(a[0:5], list(range(5, 10)))
+        self.assertEqual(a[0:5:], list(range(5, 10)))
+        self.assertEqual(a[4::-1], list(range(9, 4, -1)))
+
+    def test_setslice_cint(self):
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
+
+        a[32:47] = list(range(32, 47))
+        self.assertEqual(a[32:47], list(range(32, 47)))
+        a[32:47] = range(132, 147)
+        self.assertEqual(a[32:47:], list(range(132, 147)))
+        a[46:31:-1] = range(232, 247)
+        self.assertEqual(a[32:47:1], list(range(246, 231, -1)))
+
+        a[32:47] = range(1132, 1147)
+        self.assertEqual(a[:], b)
+        a[32:47:7] = range(3)
+        b[32:47:7] = range(3)
+        self.assertEqual(a[:], b)
+        a[33::-3] = range(12)
+        b[33::-3] = range(12)
+        self.assertEqual(a[:], b)
+
+        from operator import setitem
+
+        # TypeError: int expected instead of str instance
+        self.assertRaises(TypeError, setitem, a, slice(0, 5), "abcde")
+        # TypeError: int expected instead of str instance
+        self.assertRaises(TypeError, setitem, a, slice(0, 5),
+                          ["a", "b", "c", "d", "e"])
+        # TypeError: int expected instead of float instance
+        self.assertRaises(TypeError, setitem, a, slice(0, 5),
+                          [1, 2, 3, 4, 3.14])
+        # ValueError: Can only assign sequence of same size
+        self.assertRaises(ValueError, setitem, a, slice(0, 5), range(32))
+
+    def test_char_ptr(self):
+        s = b"abcdefghijklmnopqrstuvwxyz"
+
+        dll = CDLL(_ctypes_test.__file__)
+        dll.my_strdup.restype = POINTER(c_char)
+        dll.my_free.restype = None
+        res = dll.my_strdup(s)
+        self.assertEqual(res[:len(s)], s)
+        self.assertEqual(res[:3], s[:3])
+        self.assertEqual(res[:len(s):], s)
+        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
+        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
+        self.assertEqual(res[0:-1:-1], s[0::-1])
+
+        import operator
+        self.assertRaises(ValueError, operator.getitem,
+                          res, slice(None, None, None))
+        self.assertRaises(ValueError, operator.getitem,
+                          res, slice(0, None, None))
+        self.assertRaises(ValueError, operator.getitem,
+                          res, slice(None, 5, -1))
+        self.assertRaises(ValueError, operator.getitem,
+                          res, slice(-5, None, None))
+
+        self.assertRaises(TypeError, operator.setitem,
+                          res, slice(0, 5), "abcde")
+        dll.my_free(res)
+
+        dll.my_strdup.restype = POINTER(c_byte)
+        res = dll.my_strdup(s)
+        self.assertEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
+        self.assertEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
+        dll.my_free(res)
+
+    def test_char_ptr_with_free(self):
+        dll = CDLL(_ctypes_test.__file__)
+        s = b"abcdefghijklmnopqrstuvwxyz"
+
+        class allocated_c_char_p(c_char_p):
+            pass
+
+        dll.my_free.restype = None
+        def errcheck(result, func, args):
+            retval = result.value
+            dll.my_free(result)
+            return retval
+
+        dll.my_strdup.restype = allocated_c_char_p
+        dll.my_strdup.errcheck = errcheck
+        try:
+            res = dll.my_strdup(s)
+            self.assertEqual(res, s)
+        finally:
+            del dll.my_strdup.errcheck
+
+
+    def test_char_array(self):
+        s = b"abcdefghijklmnopqrstuvwxyz\0"
+
+        p = (c_char * 27)(*s)
+        self.assertEqual(p[:], s)
+        self.assertEqual(p[::], s)
+        self.assertEqual(p[::-1], s[::-1])
+        self.assertEqual(p[5::-2], s[5::-2])
+        self.assertEqual(p[2:5:-3], s[2:5:-3])
+
+
+    @need_symbol('c_wchar')
+    def test_wchar_ptr(self):
+        s = "abcdefghijklmnopqrstuvwxyz\0"
+
+        dll = CDLL(_ctypes_test.__file__)
+        dll.my_wcsdup.restype = POINTER(c_wchar)
+        dll.my_wcsdup.argtypes = POINTER(c_wchar),
+        dll.my_free.restype = None
+        res = dll.my_wcsdup(s[:-1])
+        self.assertEqual(res[:len(s)], s)
+        self.assertEqual(res[:len(s):], s)
+        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
+        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
+
+        import operator
+        self.assertRaises(TypeError, operator.setitem,
+                          res, slice(0, 5), "abcde")
+        dll.my_free(res)
+
+        if sizeof(c_wchar) == sizeof(c_short):
+            dll.my_wcsdup.restype = POINTER(c_short)
+        elif sizeof(c_wchar) == sizeof(c_int):
+            dll.my_wcsdup.restype = POINTER(c_int)
+        elif sizeof(c_wchar) == sizeof(c_long):
+            dll.my_wcsdup.restype = POINTER(c_long)
+        else:
+            self.skipTest('Pointers to c_wchar are not supported')
+        res = dll.my_wcsdup(s[:-1])
+        tmpl = list(range(ord("a"), ord("z")+1))
+        self.assertEqual(res[:len(s)-1], tmpl)
+        self.assertEqual(res[:len(s)-1:], tmpl)
+        self.assertEqual(res[len(s)-2:-1:-1], tmpl[::-1])
+        self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
+        dll.my_free(res)
+
+################################################################
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_stringptr.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_stringptr.py
new file mode 100644
index 0000000..c20951f
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_stringptr.py
@@ -0,0 +1,77 @@
+import unittest
+from test import support
+from ctypes import *
+
+import _ctypes_test
+
+lib = CDLL(_ctypes_test.__file__)
+
+class StringPtrTestCase(unittest.TestCase):
+
+    @support.refcount_test
+    def test__POINTER_c_char(self):
+        class X(Structure):
+            _fields_ = [("str", POINTER(c_char))]
+        x = X()
+
+        # NULL pointer access
+        self.assertRaises(ValueError, getattr, x.str, "contents")
+        b = c_buffer(b"Hello, World")
+        from sys import getrefcount as grc
+        self.assertEqual(grc(b), 2)
+        x.str = b
+        self.assertEqual(grc(b), 3)
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and c_buffer() is compatible
+        for i in range(len(b)):
+            self.assertEqual(b[i], x.str[i])
+
+        self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
+
+    def test__c_char_p(self):
+        class X(Structure):
+            _fields_ = [("str", c_char_p)]
+        x = X()
+
+        # c_char_p and Python string is compatible
+        # c_char_p and c_buffer is NOT compatible
+        self.assertEqual(x.str, None)
+        x.str = b"Hello, World"
+        self.assertEqual(x.str, b"Hello, World")
+        b = c_buffer(b"Hello, World")
+        self.assertRaises(TypeError, setattr, x, b"str", b)
+
+
+    def test_functions(self):
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+
+        # c_char_p and Python string is compatible
+        # c_char_p and c_buffer are now compatible
+        strchr.argtypes = c_char_p, c_char
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+        self.assertEqual(strchr(c_buffer(b"abcdef"), b"c"), b"cdef")
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and c_buffer() is compatible
+        strchr.argtypes = POINTER(c_char), c_char
+        buf = c_buffer(b"abcdef")
+        self.assertEqual(strchr(buf, b"c"), b"cdef")
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+
+        # XXX These calls are dangerous, because the first argument
+        # to strchr is no longer valid after the function returns!
+        # So we must keep a reference to buf separately
+
+        strchr.restype = POINTER(c_char)
+        buf = c_buffer(b"abcdef")
+        r = strchr(buf, b"c")
+        x = r[0], r[1], r[2], r[3], r[4]
+        self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
+        del buf
+        # Because r is a pointer to memory that is freed after deleting buf,
+        # the pointer is hanging and using it would reference freed memory.
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_strings.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_strings.py
new file mode 100644
index 0000000..12e2088
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_strings.py
@@ -0,0 +1,145 @@
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+
+class StringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_char * 4
+
+        buf = BUF(b"a", b"b", b"c")
+        self.assertEqual(buf.value, b"abc")
+        self.assertEqual(buf.raw, b"abc\000")
+
+        buf.value = b"ABCD"
+        self.assertEqual(buf.value, b"ABCD")
+        self.assertEqual(buf.raw, b"ABCD")
+
+        buf.value = b"x"
+        self.assertEqual(buf.value, b"x")
+        self.assertEqual(buf.raw, b"x\000CD")
+
+        buf[1] = b"Z"
+        self.assertEqual(buf.value, b"xZCD")
+        self.assertEqual(buf.raw, b"xZCD")
+
+        self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa")
+        self.assertRaises(TypeError, setattr, buf, "value", 42)
+
+    def test_c_buffer_value(self):
+        buf = c_buffer(32)
+
+        buf.value = b"Hello, World"
+        self.assertEqual(buf.value, b"Hello, World")
+
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_c_buffer_raw(self):
+        buf = c_buffer(32)
+
+        buf.raw = memoryview(b"Hello, World")
+        self.assertEqual(buf.value, b"Hello, World")
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_param_1(self):
+        BUF = c_char * 4
+        buf = BUF()
+##        print c_char_p.from_param(buf)
+
+    def test_param_2(self):
+        BUF = c_char * 4
+        buf = BUF()
+##        print BUF.from_param(c_char_p("python"))
+##        print BUF.from_param(BUF(*"pyth"))
+
+    def test_del_segfault(self):
+        BUF = c_char * 4
+        buf = BUF()
+        with self.assertRaises(AttributeError):
+            del buf.raw
+
+
+@need_symbol('c_wchar')
+class WStringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_wchar * 4
+
+        buf = BUF("a", "b", "c")
+        self.assertEqual(buf.value, "abc")
+
+        buf.value = "ABCD"
+        self.assertEqual(buf.value, "ABCD")
+
+        buf.value = "x"
+        self.assertEqual(buf.value, "x")
+
+        buf[1] = "Z"
+        self.assertEqual(buf.value, "xZCD")
+
+    @unittest.skipIf(sizeof(c_wchar) < 4,
+                     "sizeof(wchar_t) is smaller than 4 bytes")
+    def test_nonbmp(self):
+        u = chr(0x10ffff)
+        w = c_wchar(u)
+        self.assertEqual(w.value, u)
+
+
+@need_symbol('c_wchar')
+class WStringTestCase(unittest.TestCase):
+    def test_wchar(self):
+        c_wchar("x")
+        repr(byref(c_wchar("x")))
+        c_wchar("x")
+
+
+    @unittest.skip('test disabled')
+    def test_basic_wstrings(self):
+        cs = c_wstring("abcdef")
+
+        # XXX This behaviour is about to change:
+        # len returns the size of the internal buffer in bytes.
+        # This includes the terminating NUL character.
+        self.assertEqual(sizeof(cs), 14)
+
+        # The value property is the string up to the first terminating NUL.
+        self.assertEqual(cs.value, "abcdef")
+        self.assertEqual(c_wstring("abc\000def").value, "abc")
+
+        self.assertEqual(c_wstring("abc\000def").value, "abc")
+
+        # The raw property is the total buffer contents:
+        self.assertEqual(cs.raw, "abcdef\000")
+        self.assertEqual(c_wstring("abc\000def").raw, "abc\000def\000")
+
+        # We can change the value:
+        cs.value = "ab"
+        self.assertEqual(cs.value, "ab")
+        self.assertEqual(cs.raw, "ab\000\000\000\000\000")
+
+        self.assertRaises(TypeError, c_wstring, "123")
+        self.assertRaises(ValueError, c_wstring, 0)
+
+    @unittest.skip('test disabled')
+    def test_toolong(self):
+        cs = c_wstring("abcdef")
+        # Much too long string:
+        self.assertRaises(ValueError, setattr, cs, "value", "123456789012345")
+
+        # One char too long values:
+        self.assertRaises(ValueError, setattr, cs, "value", "1234567")
+
+
+def run_test(rep, msg, func, arg):
+    items = range(rep)
+    from time import perf_counter as clock
+    start = clock()
+    for i in items:
+        func(arg); func(arg); func(arg); func(arg); func(arg)
+    stop = clock()
+    print("%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep)))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_struct_fields.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_struct_fields.py
new file mode 100644
index 0000000..e444f5e
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_struct_fields.py
@@ -0,0 +1,97 @@
+import unittest
+from ctypes import *
+
+class StructFieldsTestCase(unittest.TestCase):
+    # Structure/Union classes must get 'finalized' sooner or
+    # later, when one of these things happen:
+    #
+    # 1. _fields_ is set.
+    # 2. An instance is created.
+    # 3. The type is used as field of another Structure/Union.
+    # 4. The type is subclassed
+    #
+    # When they are finalized, assigning _fields_ is no longer allowed.
+
+    def test_1_A(self):
+        class X(Structure):
+            pass
+        self.assertEqual(sizeof(X), 0) # not finalized
+        X._fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_1_B(self):
+        class X(Structure):
+            _fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_2(self):
+        class X(Structure):
+            pass
+        X()
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_3(self):
+        class X(Structure):
+            pass
+        class Y(Structure):
+            _fields_ = [("x", X)] # finalizes X
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_4(self):
+        class X(Structure):
+            pass
+        class Y(X):
+            pass
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        Y._fields_ = []
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_5(self):
+        class X(Structure):
+            _fields_ = (("char", c_char * 5),)
+
+        x = X(b'#' * 5)
+        x.char = b'a\0b\0'
+        self.assertEqual(bytes(x), b'a\x00###')
+
+    def test_6(self):
+        class X(Structure):
+            _fields_ = [("x", c_int)]
+        CField = type(X.x)
+        self.assertRaises(TypeError, CField)
+
+    def test_gh99275(self):
+        class BrokenStructure(Structure):
+            def __init_subclass__(cls, **kwargs):
+                cls._fields_ = []  # This line will fail, `stgdict` is not ready
+
+        with self.assertRaisesRegex(TypeError,
+                                    'ctypes state is not initialized'):
+            class Subclass(BrokenStructure): ...
+
+    # __set__ and __get__ should raise a TypeError in case their self
+    # argument is not a ctype instance.
+    def test___set__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__set__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__set__, 'wrong type self', 42)
+
+    def test___get__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__get__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__get__, 'wrong type self', 42)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_structures.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_structures.py
new file mode 100644
index 0000000..2168aa7
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_structures.py
@@ -0,0 +1,803 @@
+import platform
+import sys
+import unittest
+from ctypes import *
+from ctypes.test import need_symbol
+from struct import calcsize
+import _ctypes_test
+from test import support
+
+# The following definition is meant to be used from time to time to assist
+# temporarily disabling tests on specific architectures while investigations
+# are in progress, to keep buildbots happy.
+MACHINE = platform.machine()
+
+class SubclassesTest(unittest.TestCase):
+    def test_subclass(self):
+        class X(Structure):
+            _fields_ = [("a", c_int)]
+
+        class Y(X):
+            _fields_ = [("b", c_int)]
+
+        class Z(X):
+            pass
+
+        self.assertEqual(sizeof(X), sizeof(c_int))
+        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
+        self.assertEqual(sizeof(Z), sizeof(c_int))
+        self.assertEqual(X._fields_, [("a", c_int)])
+        self.assertEqual(Y._fields_, [("b", c_int)])
+        self.assertEqual(Z._fields_, [("a", c_int)])
+
+    def test_subclass_delayed(self):
+        class X(Structure):
+            pass
+        self.assertEqual(sizeof(X), 0)
+        X._fields_ = [("a", c_int)]
+
+        class Y(X):
+            pass
+        self.assertEqual(sizeof(Y), sizeof(X))
+        Y._fields_ = [("b", c_int)]
+
+        class Z(X):
+            pass
+
+        self.assertEqual(sizeof(X), sizeof(c_int))
+        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
+        self.assertEqual(sizeof(Z), sizeof(c_int))
+        self.assertEqual(X._fields_, [("a", c_int)])
+        self.assertEqual(Y._fields_, [("b", c_int)])
+        self.assertEqual(Z._fields_, [("a", c_int)])
+
+class StructureTestCase(unittest.TestCase):
+    formats = {"c": c_char,
+               "b": c_byte,
+               "B": c_ubyte,
+               "h": c_short,
+               "H": c_ushort,
+               "i": c_int,
+               "I": c_uint,
+               "l": c_long,
+               "L": c_ulong,
+               "q": c_longlong,
+               "Q": c_ulonglong,
+               "f": c_float,
+               "d": c_double,
+               }
+
+    def test_simple_structs(self):
+        for code, tp in self.formats.items():
+            class X(Structure):
+                _fields_ = [("x", c_char),
+                            ("y", tp)]
+            self.assertEqual((sizeof(X), code),
+                                 (calcsize("c%c0%c" % (code, code)), code))
+
+    def test_unions(self):
+        for code, tp in self.formats.items():
+            class X(Union):
+                _fields_ = [("x", c_char),
+                            ("y", tp)]
+            self.assertEqual((sizeof(X), code),
+                                 (calcsize("%c" % (code)), code))
+
+    def test_struct_alignment(self):
+        class X(Structure):
+            _fields_ = [("x", c_char * 3)]
+        self.assertEqual(alignment(X), calcsize("s"))
+        self.assertEqual(sizeof(X), calcsize("3s"))
+
+        class Y(Structure):
+            _fields_ = [("x", c_char * 3),
+                        ("y", c_int)]
+        self.assertEqual(alignment(Y), alignment(c_int))
+        self.assertEqual(sizeof(Y), calcsize("3si"))
+
+        class SI(Structure):
+            _fields_ = [("a", X),
+                        ("b", Y)]
+        self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
+        self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
+
+        class IS(Structure):
+            _fields_ = [("b", Y),
+                        ("a", X)]
+
+        self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
+        self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
+
+        class XX(Structure):
+            _fields_ = [("a", X),
+                        ("b", X)]
+        self.assertEqual(alignment(XX), alignment(X))
+        self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
+
+    def test_empty(self):
+        # I had problems with these
+        #
+        # Although these are pathological cases: Empty Structures!
+        class X(Structure):
+            _fields_ = []
+
+        class Y(Union):
+            _fields_ = []
+
+        # Is this really the correct alignment, or should it be 0?
+        self.assertTrue(alignment(X) == alignment(Y) == 1)
+        self.assertTrue(sizeof(X) == sizeof(Y) == 0)
+
+        class XX(Structure):
+            _fields_ = [("a", X),
+                        ("b", X)]
+
+        self.assertEqual(alignment(XX), 1)
+        self.assertEqual(sizeof(XX), 0)
+
+    def test_fields(self):
+        # test the offset and size attributes of Structure/Union fields.
+        class X(Structure):
+            _fields_ = [("x", c_int),
+                        ("y", c_char)]
+
+        self.assertEqual(X.x.offset, 0)
+        self.assertEqual(X.x.size, sizeof(c_int))
+
+        self.assertEqual(X.y.offset, sizeof(c_int))
+        self.assertEqual(X.y.size, sizeof(c_char))
+
+        # readonly
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
+
+        class X(Union):
+            _fields_ = [("x", c_int),
+                        ("y", c_char)]
+
+        self.assertEqual(X.x.offset, 0)
+        self.assertEqual(X.x.size, sizeof(c_int))
+
+        self.assertEqual(X.y.offset, 0)
+        self.assertEqual(X.y.size, sizeof(c_char))
+
+        # readonly
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
+
+        # XXX Should we check nested data types also?
+        # offset is always relative to the class...
+
+    def test_packed(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 1
+
+        self.assertEqual(sizeof(X), 9)
+        self.assertEqual(X.b.offset, 1)
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 2
+        self.assertEqual(sizeof(X), 10)
+        self.assertEqual(X.b.offset, 2)
+
+        import struct
+        longlong_size = struct.calcsize("q")
+        longlong_align = struct.calcsize("bq") - longlong_size
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 4
+        self.assertEqual(sizeof(X), min(4, longlong_align) + longlong_size)
+        self.assertEqual(X.b.offset, min(4, longlong_align))
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 8
+
+        self.assertEqual(sizeof(X), min(8, longlong_align) + longlong_size)
+        self.assertEqual(X.b.offset, min(8, longlong_align))
+
+
+        d = {"_fields_": [("a", "b"),
+                          ("b", "q")],
+             "_pack_": -1}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+
+    @support.cpython_only
+    def test_packed_c_limits(self):
+        # Issue 15989
+        import _testcapi
+        d = {"_fields_": [("a", c_byte)],
+             "_pack_": _testcapi.INT_MAX + 1}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+        d = {"_fields_": [("a", c_byte)],
+             "_pack_": _testcapi.UINT_MAX + 2}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+
+    def test_initializers(self):
+        class Person(Structure):
+            _fields_ = [("name", c_char*6),
+                        ("age", c_int)]
+
+        self.assertRaises(TypeError, Person, 42)
+        self.assertRaises(ValueError, Person, b"asldkjaslkdjaslkdj")
+        self.assertRaises(TypeError, Person, "Name", "HI")
+
+        # short enough
+        self.assertEqual(Person(b"12345", 5).name, b"12345")
+        # exact fit
+        self.assertEqual(Person(b"123456", 5).name, b"123456")
+        # too long
+        self.assertRaises(ValueError, Person, b"1234567", 5)
+
+    def test_conflicting_initializers(self):
+        class POINT(Structure):
+            _fields_ = [("phi", c_float), ("rho", c_float)]
+        # conflicting positional and keyword args
+        self.assertRaisesRegex(TypeError, "phi", POINT, 2, 3, phi=4)
+        self.assertRaisesRegex(TypeError, "rho", POINT, 2, 3, rho=4)
+
+        # too many initializers
+        self.assertRaises(TypeError, POINT, 2, 3, 4)
+
+    def test_keyword_initializers(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        pt = POINT(1, 2)
+        self.assertEqual((pt.x, pt.y), (1, 2))
+
+        pt = POINT(y=2, x=1)
+        self.assertEqual((pt.x, pt.y), (1, 2))
+
+    def test_invalid_field_types(self):
+        class POINT(Structure):
+            pass
+        self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
+
+    def test_invalid_name(self):
+        # field name must be string
+        def declare_with_name(name):
+            class S(Structure):
+                _fields_ = [(name, c_int)]
+
+        self.assertRaises(TypeError, declare_with_name, b"x")
+
+    def test_intarray_fields(self):
+        class SomeInts(Structure):
+            _fields_ = [("a", c_int * 4)]
+
+        # can use tuple to initialize array (but not list!)
+        self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
+        self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
+        self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
+        self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
+        self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
+        self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
+        self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
+        self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
+        # too long
+        # XXX Should raise ValueError?, not RuntimeError
+        self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
+
+    def test_nested_initializers(self):
+        # test initializing nested structures
+        class Phone(Structure):
+            _fields_ = [("areacode", c_char*6),
+                        ("number", c_char*12)]
+
+        class Person(Structure):
+            _fields_ = [("name", c_char * 12),
+                        ("phone", Phone),
+                        ("age", c_int)]
+
+        p = Person(b"Someone", (b"1234", b"5678"), 5)
+
+        self.assertEqual(p.name, b"Someone")
+        self.assertEqual(p.phone.areacode, b"1234")
+        self.assertEqual(p.phone.number, b"5678")
+        self.assertEqual(p.age, 5)
+
+    @need_symbol('c_wchar')
+    def test_structures_with_wchar(self):
+        class PersonW(Structure):
+            _fields_ = [("name", c_wchar * 12),
+                        ("age", c_int)]
+
+        p = PersonW("Someone \xe9")
+        self.assertEqual(p.name, "Someone \xe9")
+
+        self.assertEqual(PersonW("1234567890").name, "1234567890")
+        self.assertEqual(PersonW("12345678901").name, "12345678901")
+        # exact fit
+        self.assertEqual(PersonW("123456789012").name, "123456789012")
+        #too long
+        self.assertRaises(ValueError, PersonW, "1234567890123")
+
+    def test_init_errors(self):
+        class Phone(Structure):
+            _fields_ = [("areacode", c_char*6),
+                        ("number", c_char*12)]
+
+        class Person(Structure):
+            _fields_ = [("name", c_char * 12),
+                        ("phone", Phone),
+                        ("age", c_int)]
+
+        cls, msg = self.get_except(Person, b"Someone", (1, 2))
+        self.assertEqual(cls, RuntimeError)
+        self.assertEqual(msg,
+                             "(Phone) TypeError: "
+                             "expected bytes, int found")
+
+        cls, msg = self.get_except(Person, b"Someone", (b"a", b"b", b"c"))
+        self.assertEqual(cls, RuntimeError)
+        self.assertEqual(msg,
+                             "(Phone) TypeError: too many initializers")
+
+    def test_huge_field_name(self):
+        # issue12881: segfault with large structure field names
+        def create_class(length):
+            class S(Structure):
+                _fields_ = [('x' * length, c_int)]
+
+        for length in [10 ** i for i in range(0, 8)]:
+            try:
+                create_class(length)
+            except MemoryError:
+                # MemoryErrors are OK, we just don't want to segfault
+                pass
+
+    def get_except(self, func, *args):
+        try:
+            func(*args)
+        except Exception as detail:
+            return detail.__class__, str(detail)
+
+    def test_abstract_class(self):
+        class X(Structure):
+            _abstract_ = "something"
+        # try 'X()'
+        cls, msg = self.get_except(eval, "X()", locals())
+        self.assertEqual((cls, msg), (TypeError, "abstract class"))
+
+    def test_methods(self):
+##        class X(Structure):
+##            _fields_ = []
+
+        self.assertIn("in_dll", dir(type(Structure)))
+        self.assertIn("from_address", dir(type(Structure)))
+        self.assertIn("in_dll", dir(type(Structure)))
+
+    def test_positional_args(self):
+        # see also http://bugs.python.org/issue5042
+        class W(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+        class X(W):
+            _fields_ = [("c", c_int)]
+        class Y(X):
+            pass
+        class Z(Y):
+            _fields_ = [("d", c_int), ("e", c_int), ("f", c_int)]
+
+        z = Z(1, 2, 3, 4, 5, 6)
+        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
+                         (1, 2, 3, 4, 5, 6))
+        z = Z(1)
+        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
+                         (1, 0, 0, 0, 0, 0))
+        self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
+
+    def test_pass_by_value(self):
+        # This should mirror the Test structure
+        # in Modules/_ctypes/_ctypes_test.c
+        class Test(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+
+        s = Test()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        s.third = 0x0bad1dea
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_large_struct_update_value
+        func.argtypes = (Test,)
+        func.restype = None
+        func(s)
+        self.assertEqual(s.first, 0xdeadbeef)
+        self.assertEqual(s.second, 0xcafebabe)
+        self.assertEqual(s.third, 0x0bad1dea)
+
+    def test_pass_by_value_finalizer(self):
+        # bpo-37140: Similar to test_pass_by_value(), but the Python structure
+        # has a finalizer (__del__() method): the finalizer must only be called
+        # once.
+
+        finalizer_calls = []
+
+        class Test(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+            def __del__(self):
+                finalizer_calls.append("called")
+
+        s = Test(1, 2, 3)
+        # Test the StructUnionType_paramfunc() code path which copies the
+        # structure: if the structure is larger than sizeof(void*).
+        self.assertGreater(sizeof(s), sizeof(c_void_p))
+
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_large_struct_update_value
+        func.argtypes = (Test,)
+        func.restype = None
+        func(s)
+        # bpo-37140: Passing the structure by reference must not call
+        # its finalizer!
+        self.assertEqual(finalizer_calls, [])
+        self.assertEqual(s.first, 1)
+        self.assertEqual(s.second, 2)
+        self.assertEqual(s.third, 3)
+
+        # The finalizer must be called exactly once
+        s = None
+        support.gc_collect()
+        self.assertEqual(finalizer_calls, ["called"])
+
+    def test_pass_by_value_in_register(self):
+        class X(Structure):
+            _fields_ = [
+                ('first', c_uint),
+                ('second', c_uint)
+            ]
+
+        s = X()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_reg_struct_update_value
+        func.argtypes = (X,)
+        func.restype = None
+        func(s)
+        self.assertEqual(s.first, 0xdeadbeef)
+        self.assertEqual(s.second, 0xcafebabe)
+        got = X.in_dll(dll, "last_tfrsuv_arg")
+        self.assertEqual(s.first, got.first)
+        self.assertEqual(s.second, got.second)
+
+    def test_array_in_struct(self):
+        # See bpo-22273
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+        class Test2(Structure):
+            _fields_ = [
+                ('data', c_ubyte * 16),
+            ]
+
+        class Test3(Structure):
+            _fields_ = [
+                ('data', c_double * 2),
+            ]
+
+        class Test3A(Structure):
+            _fields_ = [
+                ('data', c_float * 2),
+            ]
+
+        class Test3B(Test3A):
+            _fields_ = [
+                ('more_data', c_float * 2),
+            ]
+
+        s = Test2()
+        expected = 0
+        for i in range(16):
+            s.data[i] = i
+            expected += i
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_array_in_struct1
+        func.restype = c_int
+        func.argtypes = (Test2,)
+        result = func(s)
+        self.assertEqual(result, expected)
+        # check the passed-in struct hasn't changed
+        for i in range(16):
+            self.assertEqual(s.data[i], i)
+
+        s = Test3()
+        s.data[0] = 3.14159
+        s.data[1] = 2.71828
+        expected = 3.14159 + 2.71828
+        func = dll._testfunc_array_in_struct2
+        func.restype = c_double
+        func.argtypes = (Test3,)
+        result = func(s)
+        self.assertEqual(result, expected)
+        # check the passed-in struct hasn't changed
+        self.assertEqual(s.data[0], 3.14159)
+        self.assertEqual(s.data[1], 2.71828)
+
+        s = Test3B()
+        s.data[0] = 3.14159
+        s.data[1] = 2.71828
+        s.more_data[0] = -3.0
+        s.more_data[1] = -2.0
+
+        expected = 3.14159 + 2.71828 - 5.0
+        func = dll._testfunc_array_in_struct2a
+        func.restype = c_double
+        func.argtypes = (Test3B,)
+        result = func(s)
+        self.assertAlmostEqual(result, expected, places=6)
+        # check the passed-in struct hasn't changed
+        self.assertAlmostEqual(s.data[0], 3.14159, places=6)
+        self.assertAlmostEqual(s.data[1], 2.71828, places=6)
+        self.assertAlmostEqual(s.more_data[0], -3.0, places=6)
+        self.assertAlmostEqual(s.more_data[1], -2.0, places=6)
+
+    def test_38368(self):
+        class U(Union):
+            _fields_ = [
+                ('f1', c_uint8 * 16),
+                ('f2', c_uint16 * 8),
+                ('f3', c_uint32 * 4),
+            ]
+        u = U()
+        u.f3[0] = 0x01234567
+        u.f3[1] = 0x89ABCDEF
+        u.f3[2] = 0x76543210
+        u.f3[3] = 0xFEDCBA98
+        f1 = [u.f1[i] for i in range(16)]
+        f2 = [u.f2[i] for i in range(8)]
+        if sys.byteorder == 'little':
+            self.assertEqual(f1, [0x67, 0x45, 0x23, 0x01,
+                                  0xef, 0xcd, 0xab, 0x89,
+                                  0x10, 0x32, 0x54, 0x76,
+                                  0x98, 0xba, 0xdc, 0xfe])
+            self.assertEqual(f2, [0x4567, 0x0123, 0xcdef, 0x89ab,
+                                  0x3210, 0x7654, 0xba98, 0xfedc])
+
+    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
+    def test_union_by_value(self):
+        # See bpo-16575
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+
+        class Nested1(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('another_int', c_int),
+            ]
+
+        class Test4(Union):
+            _fields_ = [
+                ('a_long', c_long),
+                ('a_struct', Nested1),
+            ]
+
+        class Nested2(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('a_union', Test4),
+            ]
+
+        class Test5(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('nested', Nested2),
+                ('another_int', c_int),
+            ]
+
+        test4 = Test4()
+        dll = CDLL(_ctypes_test.__file__)
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_union_by_value1
+            func.restype = c_long
+            func.argtypes = (Test4,)
+            result = func(test4)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+        test5 = Test5()
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_union_by_value2
+            func.restype = c_long
+            func.argtypes = (Test5,)
+            result = func(test5)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+
+        # passing by reference should be OK
+        test4.a_long = 12345;
+        func = dll._testfunc_union_by_reference1
+        func.restype = c_long
+        func.argtypes = (POINTER(Test4),)
+        result = func(byref(test4))
+        self.assertEqual(result, 12345)
+        self.assertEqual(test4.a_long, 0)
+        self.assertEqual(test4.a_struct.an_int, 0)
+        self.assertEqual(test4.a_struct.another_int, 0)
+        test4.a_struct.an_int = 0x12340000
+        test4.a_struct.another_int = 0x5678
+        func = dll._testfunc_union_by_reference2
+        func.restype = c_long
+        func.argtypes = (POINTER(Test4),)
+        result = func(byref(test4))
+        self.assertEqual(result, 0x12345678)
+        self.assertEqual(test4.a_long, 0)
+        self.assertEqual(test4.a_struct.an_int, 0)
+        self.assertEqual(test4.a_struct.another_int, 0)
+        test5.an_int = 0x12000000
+        test5.nested.an_int = 0x345600
+        test5.another_int = 0x78
+        func = dll._testfunc_union_by_reference3
+        func.restype = c_long
+        func.argtypes = (POINTER(Test5),)
+        result = func(byref(test5))
+        self.assertEqual(result, 0x12345678)
+        self.assertEqual(test5.an_int, 0)
+        self.assertEqual(test5.nested.an_int, 0)
+        self.assertEqual(test5.another_int, 0)
+
+    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
+    def test_bitfield_by_value(self):
+        # See bpo-16576
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+
+        class Test6(Structure):
+            _fields_ = [
+                ('A', c_int, 1),
+                ('B', c_int, 2),
+                ('C', c_int, 3),
+                ('D', c_int, 2),
+            ]
+
+        test6 = Test6()
+        # As these are signed int fields, all are logically -1 due to sign
+        # extension.
+        test6.A = 1
+        test6.B = 3
+        test6.C = 7
+        test6.D = 3
+        dll = CDLL(_ctypes_test.__file__)
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_bitfield_by_value1
+            func.restype = c_long
+            func.argtypes = (Test6,)
+            result = func(test6)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a struct/union with a bitfield by value, which is '
+                         'unsupported.')
+        # passing by reference should be OK
+        func = dll._testfunc_bitfield_by_reference1
+        func.restype = c_long
+        func.argtypes = (POINTER(Test6),)
+        result = func(byref(test6))
+        self.assertEqual(result, -4)
+        self.assertEqual(test6.A, 0)
+        self.assertEqual(test6.B, 0)
+        self.assertEqual(test6.C, 0)
+        self.assertEqual(test6.D, 0)
+
+        class Test7(Structure):
+            _fields_ = [
+                ('A', c_uint, 1),
+                ('B', c_uint, 2),
+                ('C', c_uint, 3),
+                ('D', c_uint, 2),
+            ]
+        test7 = Test7()
+        test7.A = 1
+        test7.B = 3
+        test7.C = 7
+        test7.D = 3
+        func = dll._testfunc_bitfield_by_reference2
+        func.restype = c_long
+        func.argtypes = (POINTER(Test7),)
+        result = func(byref(test7))
+        self.assertEqual(result, 14)
+        self.assertEqual(test7.A, 0)
+        self.assertEqual(test7.B, 0)
+        self.assertEqual(test7.C, 0)
+        self.assertEqual(test7.D, 0)
+
+        # for a union with bitfields, the union check happens first
+        class Test8(Union):
+            _fields_ = [
+                ('A', c_int, 1),
+                ('B', c_int, 2),
+                ('C', c_int, 3),
+                ('D', c_int, 2),
+            ]
+
+        test8 = Test8()
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_bitfield_by_value2
+            func.restype = c_long
+            func.argtypes = (Test8,)
+            result = func(test8)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+
+class PointerMemberTestCase(unittest.TestCase):
+
+    def test(self):
+        # a Structure with a POINTER field
+        class S(Structure):
+            _fields_ = [("array", POINTER(c_int))]
+
+        s = S()
+        # We can assign arrays of the correct type
+        s.array = (c_int * 3)(1, 2, 3)
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [1, 2, 3])
+
+        # The following are bugs, but are included here because the unittests
+        # also describe the current behaviour.
+        #
+        # This fails with SystemError: bad arg to internal function
+        # or with IndexError (with a patch I have)
+
+        s.array[0] = 42
+
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [42, 2, 3])
+
+        s.array[0] = 1
+
+##        s.array[1] = 42
+
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [1, 2, 3])
+
+    def test_none_to_pointer_fields(self):
+        class S(Structure):
+            _fields_ = [("x", c_int),
+                        ("p", POINTER(c_int))]
+
+        s = S()
+        s.x = 12345678
+        s.p = None
+        self.assertEqual(s.x, 12345678)
+
+class TestRecursiveStructure(unittest.TestCase):
+    def test_contains_itself(self):
+        class Recursive(Structure):
+            pass
+
+        try:
+            Recursive._fields_ = [("next", Recursive)]
+        except AttributeError as details:
+            self.assertIn("Structure or union cannot contain itself",
+                          str(details))
+        else:
+            self.fail("Structure or union cannot contain itself")
+
+
+    def test_vice_versa(self):
+        class First(Structure):
+            pass
+        class Second(Structure):
+            pass
+
+        First._fields_ = [("second", Second)]
+
+        try:
+            Second._fields_ = [("first", First)]
+        except AttributeError as details:
+            self.assertIn("_fields_ is final", str(details))
+        else:
+            self.fail("AttributeError not raised")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unaligned_structures.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unaligned_structures.py
new file mode 100644
index 0000000..ee7fb45
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unaligned_structures.py
@@ -0,0 +1,43 @@
+import sys, unittest
+from ctypes import *
+
+structures = []
+byteswapped_structures = []
+
+
+if sys.byteorder == "little":
+    SwappedStructure = BigEndianStructure
+else:
+    SwappedStructure = LittleEndianStructure
+
+for typ in [c_short, c_int, c_long, c_longlong,
+            c_float, c_double,
+            c_ushort, c_uint, c_ulong, c_ulonglong]:
+    class X(Structure):
+        _pack_ = 1
+        _fields_ = [("pad", c_byte),
+                    ("value", typ)]
+    class Y(SwappedStructure):
+        _pack_ = 1
+        _fields_ = [("pad", c_byte),
+                    ("value", typ)]
+    structures.append(X)
+    byteswapped_structures.append(Y)
+
+class TestStructures(unittest.TestCase):
+    def test_native(self):
+        for typ in structures:
+            self.assertEqual(typ.value.offset, 1)
+            o = typ()
+            o.value = 4
+            self.assertEqual(o.value, 4)
+
+    def test_swapped(self):
+        for typ in byteswapped_structures:
+            self.assertEqual(typ.value.offset, 1)
+            o = typ()
+            o.value = 4
+            self.assertEqual(o.value, 4)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unicode.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unicode.py
new file mode 100644
index 0000000..60c7542
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_unicode.py
@@ -0,0 +1,64 @@
+import unittest
+import ctypes
+from ctypes.test import need_symbol
+
+import _ctypes_test
+
+@need_symbol('c_wchar')
+class UnicodeTestCase(unittest.TestCase):
+    def test_wcslen(self):
+        dll = ctypes.CDLL(_ctypes_test.__file__)
+        wcslen = dll.my_wcslen
+        wcslen.argtypes = [ctypes.c_wchar_p]
+
+        self.assertEqual(wcslen("abc"), 3)
+        self.assertEqual(wcslen("ab\u2070"), 3)
+        self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_unicode_buffer("abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_unicode_buffer("ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], '\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], 'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], "")
+
+    def test_embedded_null(self):
+        class TestStruct(ctypes.Structure):
+            _fields_ = [("unicode", ctypes.c_wchar_p)]
+        t = TestStruct()
+        # This would raise a ValueError:
+        t.unicode = "foo\0bar\0\0"
+
+
+func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
+
+class StringTestCase(UnicodeTestCase):
+    def setUp(self):
+        func.argtypes = [ctypes.c_char_p]
+        func.restype = ctypes.c_char_p
+
+    def tearDown(self):
+        func.argtypes = None
+        func.restype = ctypes.c_int
+
+    def test_func(self):
+        self.assertEqual(func(b"abc\xe4"), b"abc\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_string_buffer(b"abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], b'\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], b'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], b"")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_values.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_values.py
new file mode 100644
index 0000000..435fdd2
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_values.py
@@ -0,0 +1,103 @@
+"""
+A testcase which accesses *values* in a dll.
+"""
+
+import _imp
+import importlib.util
+import unittest
+import sys
+from ctypes import *
+from test.support import import_helper
+
+import _ctypes_test
+
+class ValuesTestCase(unittest.TestCase):
+
+    def test_an_integer(self):
+        # This test checks and changes an integer stored inside the
+        # _ctypes_test dll/shared lib.
+        ctdll = CDLL(_ctypes_test.__file__)
+        an_integer = c_int.in_dll(ctdll, "an_integer")
+        x = an_integer.value
+        self.assertEqual(x, ctdll.get_an_integer())
+        an_integer.value *= 2
+        self.assertEqual(x*2, ctdll.get_an_integer())
+        # To avoid test failures when this test is repeated several
+        # times the original value must be restored
+        an_integer.value = x
+        self.assertEqual(x, ctdll.get_an_integer())
+
+    def test_undefined(self):
+        ctdll = CDLL(_ctypes_test.__file__)
+        self.assertRaises(ValueError, c_int.in_dll, ctdll, "Undefined_Symbol")
+
+class PythonValuesTestCase(unittest.TestCase):
+    """This test only works when python itself is a dll/shared library"""
+
+    def test_optimizeflag(self):
+        # This test accesses the Py_OptimizeFlag integer, which is
+        # exported by the Python dll and should match the sys.flags value
+
+        opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
+        self.assertEqual(opt, sys.flags.optimize)
+
+    def test_frozentable(self):
+        # Python exports a PyImport_FrozenModules symbol. This is a
+        # pointer to an array of struct _frozen entries.  The end of the
+        # array is marked by an entry containing a NULL name and zero
+        # size.
+
+        # In standard Python, this table contains a __hello__
+        # module, and a __phello__ package containing a spam
+        # module.
+        class struct_frozen(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("code", POINTER(c_ubyte)),
+                        ("size", c_int),
+                        ("is_package", c_int),
+                        ("get_code", POINTER(c_ubyte)),  # Function ptr
+                        ]
+        FrozenTable = POINTER(struct_frozen)
+
+        modules = []
+        for group in ["Bootstrap", "Stdlib", "Test"]:
+            ft = FrozenTable.in_dll(pythonapi, f"_PyImport_Frozen{group}")
+            # ft is a pointer to the struct_frozen entries:
+            for entry in ft:
+                # This is dangerous. We *can* iterate over a pointer, but
+                # the loop will not terminate (maybe with an access
+                # violation;-) because the pointer instance has no size.
+                if entry.name is None:
+                    break
+                modname = entry.name.decode("ascii")
+                modules.append(modname)
+                with self.subTest(modname):
+                    if entry.size != 0:
+                        # Do a sanity check on entry.size and entry.code.
+                        self.assertGreater(abs(entry.size), 10)
+                        self.assertTrue([entry.code[i] for i in range(abs(entry.size))])
+                    # Check the module's package-ness.
+                    with import_helper.frozen_modules():
+                        spec = importlib.util.find_spec(modname)
+                    if entry.is_package:
+                        # It's a package.
+                        self.assertIsNotNone(spec.submodule_search_locations)
+                    else:
+                        self.assertIsNone(spec.submodule_search_locations)
+
+        with import_helper.frozen_modules():
+            expected = _imp._frozen_module_names()
+        self.maxDiff = None
+        self.assertEqual(modules, expected,
+                         "_PyImport_FrozenBootstrap example "
+                         "in Doc/library/ctypes.rst may be out of date")
+
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[struct_frozen]
+
+    def test_undefined(self):
+        self.assertRaises(ValueError, c_int.in_dll, pythonapi,
+                          "Undefined_Symbol")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_varsize_struct.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_varsize_struct.py
new file mode 100644
index 0000000..f409500
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_varsize_struct.py
@@ -0,0 +1,50 @@
+from ctypes import *
+import unittest
+
+class VarSizeTest(unittest.TestCase):
+    def test_resize(self):
+        class X(Structure):
+            _fields_ = [("item", c_int),
+                        ("array", c_int * 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_int) * 2)
+        x = X()
+        x.item = 42
+        x.array[0] = 100
+        self.assertEqual(sizeof(x), sizeof(c_int) * 2)
+
+        # make room for one additional item
+        new_size = sizeof(X) + sizeof(c_int) * 1
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+        # make room for 10 additional items
+        new_size = sizeof(X) + sizeof(c_int) * 9
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+        # make room for one additional item
+        new_size = sizeof(X) + sizeof(c_int) * 1
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+    def test_array_invalid_length(self):
+        # cannot create arrays with non-positive size
+        self.assertRaises(ValueError, lambda: c_int * -1)
+        self.assertRaises(ValueError, lambda: c_int * -3)
+
+    def test_zerosized_array(self):
+        array = (c_int * 0)()
+        # accessing elements of zero-sized arrays raise IndexError
+        self.assertRaises(IndexError, array.__setitem__, 0, None)
+        self.assertRaises(IndexError, array.__getitem__, 0)
+        self.assertRaises(IndexError, array.__setitem__, 1, None)
+        self.assertRaises(IndexError, array.__getitem__, 1)
+        self.assertRaises(IndexError, array.__setitem__, -1, None)
+        self.assertRaises(IndexError, array.__getitem__, -1)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_win32.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_win32.py
new file mode 100644
index 0000000..e51bdc8
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_win32.py
@@ -0,0 +1,136 @@
+# Windows specific tests
+
+from ctypes import *
+import unittest, sys
+from test import support
+
+import _ctypes_test
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class FunctionCallTestCase(unittest.TestCase):
+    @unittest.skipUnless('MSC' in sys.version, "SEH only supported by MSC")
+    @unittest.skipIf(sys.executable.lower().endswith('_d.exe'),
+                     "SEH not enabled in debug builds")
+    def test_SEH(self):
+        # Disable faulthandler to prevent logging the warning:
+        # "Windows fatal exception: access violation"
+        with support.disable_faulthandler():
+            # Call functions with invalid arguments, and make sure
+            # that access violations are trapped and raise an
+            # exception.
+            self.assertRaises(OSError, windll.kernel32.GetModuleHandleA, 32)
+
+    def test_noargs(self):
+        # This is a special case on win32 x64
+        windll.user32.GetDesktopWindow()
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class ReturnStructSizesTestCase(unittest.TestCase):
+    def test_sizes(self):
+        dll = CDLL(_ctypes_test.__file__)
+        for i in range(1, 11):
+            fields = [ (f"f{f}", c_char) for f in range(1, i + 1)]
+            class S(Structure):
+                _fields_ = fields
+            f = getattr(dll, f"TestSize{i}")
+            f.restype = S
+            res = f()
+            for i, f in enumerate(fields):
+                value = getattr(res, f[0])
+                expected = bytes([ord('a') + i])
+                self.assertEqual(value, expected)
+
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class TestWintypes(unittest.TestCase):
+    def test_HWND(self):
+        from ctypes import wintypes
+        self.assertEqual(sizeof(wintypes.HWND), sizeof(c_void_p))
+
+    def test_PARAM(self):
+        from ctypes import wintypes
+        self.assertEqual(sizeof(wintypes.WPARAM),
+                             sizeof(c_void_p))
+        self.assertEqual(sizeof(wintypes.LPARAM),
+                             sizeof(c_void_p))
+
+    def test_COMError(self):
+        from _ctypes import COMError
+        if support.HAVE_DOCSTRINGS:
+            self.assertEqual(COMError.__doc__,
+                             "Raised when a COM method call failed.")
+
+        ex = COMError(-1, "text", ("details",))
+        self.assertEqual(ex.hresult, -1)
+        self.assertEqual(ex.text, "text")
+        self.assertEqual(ex.details, ("details",))
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class TestWinError(unittest.TestCase):
+    def test_winerror(self):
+        # see Issue 16169
+        import errno
+        ERROR_INVALID_PARAMETER = 87
+        msg = FormatError(ERROR_INVALID_PARAMETER).strip()
+        args = (errno.EINVAL, msg, None, ERROR_INVALID_PARAMETER)
+
+        e = WinError(ERROR_INVALID_PARAMETER)
+        self.assertEqual(e.args, args)
+        self.assertEqual(e.errno, errno.EINVAL)
+        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
+
+        windll.kernel32.SetLastError(ERROR_INVALID_PARAMETER)
+        try:
+            raise WinError()
+        except OSError as exc:
+            e = exc
+        self.assertEqual(e.args, args)
+        self.assertEqual(e.errno, errno.EINVAL)
+        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
+
+class Structures(unittest.TestCase):
+    def test_struct_by_value(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_long),
+                        ("y", c_long)]
+
+        class RECT(Structure):
+            _fields_ = [("left", c_long),
+                        ("top", c_long),
+                        ("right", c_long),
+                        ("bottom", c_long)]
+
+        dll = CDLL(_ctypes_test.__file__)
+
+        pt = POINT(15, 25)
+        left = c_long.in_dll(dll, 'left')
+        top = c_long.in_dll(dll, 'top')
+        right = c_long.in_dll(dll, 'right')
+        bottom = c_long.in_dll(dll, 'bottom')
+        rect = RECT(left, top, right, bottom)
+        PointInRect = dll.PointInRect
+        PointInRect.argtypes = [POINTER(RECT), POINT]
+        self.assertEqual(1, PointInRect(byref(rect), pt))
+
+        ReturnRect = dll.ReturnRect
+        ReturnRect.argtypes = [c_int, RECT, POINTER(RECT), POINT, RECT,
+                               POINTER(RECT), POINT, RECT]
+        ReturnRect.restype = RECT
+        for i in range(4):
+            ret = ReturnRect(i, rect, pointer(rect), pt, rect,
+                         byref(rect), pt, rect)
+            # the c function will check and modify ret if something is
+            # passed in improperly
+            self.assertEqual(ret.left, left.value)
+            self.assertEqual(ret.right, right.value)
+            self.assertEqual(ret.top, top.value)
+            self.assertEqual(ret.bottom, bottom.value)
+
+        # to not leak references, we must clean _pointer_type_cache
+        from ctypes import _pointer_type_cache
+        del _pointer_type_cache[RECT]
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_wintypes.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_wintypes.py
new file mode 100644
index 0000000..243d596
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/test/test_wintypes.py
@@ -0,0 +1,43 @@
+import unittest
+
+# also work on POSIX
+
+from ctypes import *
+from ctypes import wintypes
+
+
+class WinTypesTest(unittest.TestCase):
+    def test_variant_bool(self):
+        # reads 16-bits from memory, anything non-zero is True
+        for true_value in (1, 32767, 32768, 65535, 65537):
+            true = POINTER(c_int16)(c_int16(true_value))
+            value = cast(true, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(True)')
+
+            vb = wintypes.VARIANT_BOOL()
+            self.assertIs(vb.value, False)
+            vb.value = True
+            self.assertIs(vb.value, True)
+            vb.value = true_value
+            self.assertIs(vb.value, True)
+
+        for false_value in (0, 65536, 262144, 2**33):
+            false = POINTER(c_int16)(c_int16(false_value))
+            value = cast(false, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(False)')
+
+        # allow any bool conversion on assignment to value
+        for set_value in (65536, 262144, 2**33):
+            vb = wintypes.VARIANT_BOOL()
+            vb.value = set_value
+            self.assertIs(vb.value, True)
+
+        vb = wintypes.VARIANT_BOOL()
+        vb.value = [2, 3]
+        self.assertIs(vb.value, True)
+        vb.value = []
+        self.assertIs(vb.value, False)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/util.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/util.py
new file mode 100644
index 0000000..0c2510e
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/util.py
@@ -0,0 +1,376 @@
+import os
+import shutil
+import subprocess
+import sys
+
+# find_library(name) returns the pathname of a library, or None.
+if os.name == "nt":
+
+    def _get_build_version():
+        """Return the version of MSVC that was used to build Python.
+
+        For Python 2.3 and up, the version number is included in
+        sys.version.  For earlier versions, assume the compiler is MSVC 6.
+        """
+        # This function was copied from Lib/distutils/msvccompiler.py
+        prefix = "MSC v."
+        i = sys.version.find(prefix)
+        if i == -1:
+            return 6
+        i = i + len(prefix)
+        s, rest = sys.version[i:].split(" ", 1)
+        majorVersion = int(s[:-2]) - 6
+        if majorVersion >= 13:
+            majorVersion += 1
+        minorVersion = int(s[2:3]) / 10.0
+        # I don't think paths are affected by minor version in version 6
+        if majorVersion == 6:
+            minorVersion = 0
+        if majorVersion >= 6:
+            return majorVersion + minorVersion
+        # else we don't know what version of the compiler this is
+        return None
+
+    def find_msvcrt():
+        """Return the name of the VC runtime dll"""
+        version = _get_build_version()
+        if version is None:
+            # better be safe than sorry
+            return None
+        if version <= 6:
+            clibname = 'msvcrt'
+        elif version <= 13:
+            clibname = 'msvcr%d' % (version * 10)
+        else:
+            # CRT is no longer directly loadable. See issue23606 for the
+            # discussion about alternative approaches.
+            return None
+
+        # If python was built with in debug mode
+        import importlib.machinery
+        if '_d.pyd' in importlib.machinery.EXTENSION_SUFFIXES:
+            clibname += 'd'
+        return clibname+'.dll'
+
+    def find_library(name):
+        if name in ('c', 'm'):
+            return find_msvcrt()
+        # See MSDN for the REAL search order.
+        for directory in os.environ['PATH'].split(os.pathsep):
+            fname = os.path.join(directory, name)
+            if os.path.isfile(fname):
+                return fname
+            if fname.lower().endswith(".dll"):
+                continue
+            fname = fname + ".dll"
+            if os.path.isfile(fname):
+                return fname
+        return None
+
+elif os.name == "posix" and sys.platform == "darwin":
+    from ctypes.macholib.dyld import dyld_find as _dyld_find
+    def find_library(name):
+        possible = ['lib%s.dylib' % name,
+                    '%s.dylib' % name,
+                    '%s.framework/%s' % (name, name)]
+        for name in possible:
+            try:
+                return _dyld_find(name)
+            except ValueError:
+                continue
+        return None
+
+elif sys.platform.startswith("aix"):
+    # AIX has two styles of storing shared libraries
+    # GNU auto_tools refer to these as svr4 and aix
+    # svr4 (System V Release 4) is a regular file, often with .so as suffix
+    # AIX style uses an archive (suffix .a) with members (e.g., shr.o, libssl.so)
+    # see issue#26439 and _aix.py for more details
+
+    from ctypes._aix import find_library
+
+elif os.name == "posix":
+    # Andreas Degert's find functions, using gcc, /sbin/ldconfig, objdump
+    import re, tempfile
+
+    def _is_elf(filename):
+        "Return True if the given file is an ELF file"
+        elf_header = b'\x7fELF'
+        with open(filename, 'br') as thefile:
+            return thefile.read(4) == elf_header
+
+    def _findLib_gcc(name):
+        # Run GCC's linker with the -t (aka --trace) option and examine the
+        # library name it prints out. The GCC command will fail because we
+        # haven't supplied a proper program with main(), but that does not
+        # matter.
+        expr = os.fsencode(r'[^\(\)\s]*lib%s\.[^\(\)\s]*' % re.escape(name))
+
+        c_compiler = shutil.which('gcc')
+        if not c_compiler:
+            c_compiler = shutil.which('cc')
+        if not c_compiler:
+            # No C compiler available, give up
+            return None
+
+        temp = tempfile.NamedTemporaryFile()
+        try:
+            args = [c_compiler, '-Wl,-t', '-o', temp.name, '-l' + name]
+
+            env = dict(os.environ)
+            env['LC_ALL'] = 'C'
+            env['LANG'] = 'C'
+            try:
+                proc = subprocess.Popen(args,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.STDOUT,
+                                        env=env)
+            except OSError:  # E.g. bad executable
+                return None
+            with proc:
+                trace = proc.stdout.read()
+        finally:
+            try:
+                temp.close()
+            except FileNotFoundError:
+                # Raised if the file was already removed, which is the normal
+                # behaviour of GCC if linking fails
+                pass
+        res = re.findall(expr, trace)
+        if not res:
+            return None
+
+        for file in res:
+            # Check if the given file is an elf file: gcc can report
+            # some files that are linker scripts and not actual
+            # shared objects. See bpo-41976 for more details
+            if not _is_elf(file):
+                continue
+            return os.fsdecode(file)
+
+
+    if sys.platform == "sunos5":
+        # use /usr/ccs/bin/dump on solaris
+        def _get_soname(f):
+            if not f:
+                return None
+
+            try:
+                proc = subprocess.Popen(("/usr/ccs/bin/dump", "-Lpv", f),
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.DEVNULL)
+            except OSError:  # E.g. command not found
+                return None
+            with proc:
+                data = proc.stdout.read()
+            res = re.search(br'\[.*\]\sSONAME\s+([^\s]+)', data)
+            if not res:
+                return None
+            return os.fsdecode(res.group(1))
+    else:
+        def _get_soname(f):
+            # assuming GNU binutils / ELF
+            if not f:
+                return None
+            objdump = shutil.which('objdump')
+            if not objdump:
+                # objdump is not available, give up
+                return None
+
+            try:
+                proc = subprocess.Popen((objdump, '-p', '-j', '.dynamic', f),
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.DEVNULL)
+            except OSError:  # E.g. bad executable
+                return None
+            with proc:
+                dump = proc.stdout.read()
+            res = re.search(br'\sSONAME\s+([^\s]+)', dump)
+            if not res:
+                return None
+            return os.fsdecode(res.group(1))
+
+    if sys.platform.startswith(("freebsd", "openbsd", "dragonfly")):
+
+        def _num_version(libname):
+            # "libxyz.so.MAJOR.MINOR" => [ MAJOR, MINOR ]
+            parts = libname.split(b".")
+            nums = []
+            try:
+                while parts:
+                    nums.insert(0, int(parts.pop()))
+            except ValueError:
+                pass
+            return nums or [sys.maxsize]
+
+        def find_library(name):
+            ename = re.escape(name)
+            expr = r':-l%s\.\S+ => \S*/(lib%s\.\S+)' % (ename, ename)
+            expr = os.fsencode(expr)
+
+            try:
+                proc = subprocess.Popen(('/sbin/ldconfig', '-r'),
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.DEVNULL)
+            except OSError:  # E.g. command not found
+                data = b''
+            else:
+                with proc:
+                    data = proc.stdout.read()
+
+            res = re.findall(expr, data)
+            if not res:
+                return _get_soname(_findLib_gcc(name))
+            res.sort(key=_num_version)
+            return os.fsdecode(res[-1])
+
+    elif sys.platform == "sunos5":
+
+        def _findLib_crle(name, is64):
+            if not os.path.exists('/usr/bin/crle'):
+                return None
+
+            env = dict(os.environ)
+            env['LC_ALL'] = 'C'
+
+            if is64:
+                args = ('/usr/bin/crle', '-64')
+            else:
+                args = ('/usr/bin/crle',)
+
+            paths = None
+            try:
+                proc = subprocess.Popen(args,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.DEVNULL,
+                                        env=env)
+            except OSError:  # E.g. bad executable
+                return None
+            with proc:
+                for line in proc.stdout:
+                    line = line.strip()
+                    if line.startswith(b'Default Library Path (ELF):'):
+                        paths = os.fsdecode(line).split()[4]
+
+            if not paths:
+                return None
+
+            for dir in paths.split(":"):
+                libfile = os.path.join(dir, "lib%s.so" % name)
+                if os.path.exists(libfile):
+                    return libfile
+
+            return None
+
+        def find_library(name, is64 = False):
+            return _get_soname(_findLib_crle(name, is64) or _findLib_gcc(name))
+
+    else:
+
+        def _findSoname_ldconfig(name):
+            import struct
+            if struct.calcsize('l') == 4:
+                machine = os.uname().machine + '-32'
+            else:
+                machine = os.uname().machine + '-64'
+            mach_map = {
+                'x86_64-64': 'libc6,x86-64',
+                'ppc64-64': 'libc6,64bit',
+                'sparc64-64': 'libc6,64bit',
+                's390x-64': 'libc6,64bit',
+                'ia64-64': 'libc6,IA-64',
+                }
+            abi_type = mach_map.get(machine, 'libc6')
+
+            # XXX assuming GLIBC's ldconfig (with option -p)
+            regex = r'\s+(lib%s\.[^\s]+)\s+\(%s'
+            regex = os.fsencode(regex % (re.escape(name), abi_type))
+            try:
+                with subprocess.Popen(['/sbin/ldconfig', '-p'],
+                                      stdin=subprocess.DEVNULL,
+                                      stderr=subprocess.DEVNULL,
+                                      stdout=subprocess.PIPE,
+                                      env={'LC_ALL': 'C', 'LANG': 'C'}) as p:
+                    res = re.search(regex, p.stdout.read())
+                    if res:
+                        return os.fsdecode(res.group(1))
+            except OSError:
+                pass
+
+        def _findLib_ld(name):
+            # See issue #9998 for why this is needed
+            expr = r'[^\(\)\s]*lib%s\.[^\(\)\s]*' % re.escape(name)
+            cmd = ['ld', '-t']
+            libpath = os.environ.get('LD_LIBRARY_PATH')
+            if libpath:
+                for d in libpath.split(':'):
+                    cmd.extend(['-L', d])
+            cmd.extend(['-o', os.devnull, '-l%s' % name])
+            result = None
+            try:
+                p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                                     stderr=subprocess.PIPE,
+                                     universal_newlines=True)
+                out, _ = p.communicate()
+                res = re.findall(expr, os.fsdecode(out))
+                for file in res:
+                    # Check if the given file is an elf file: gcc can report
+                    # some files that are linker scripts and not actual
+                    # shared objects. See bpo-41976 for more details
+                    if not _is_elf(file):
+                        continue
+                    return os.fsdecode(file)
+            except Exception:
+                pass  # result will be None
+            return result
+
+        def find_library(name):
+            # See issue #9998
+            return _findSoname_ldconfig(name) or \
+                   _get_soname(_findLib_gcc(name)) or _get_soname(_findLib_ld(name))
+
+################################################################
+# test code
+
+def test():
+    from ctypes import cdll
+    if os.name == "nt":
+        print(cdll.msvcrt)
+        print(cdll.load("msvcrt"))
+        print(find_library("msvcrt"))
+
+    if os.name == "posix":
+        # find and load_version
+        print(find_library("m"))
+        print(find_library("c"))
+        print(find_library("bz2"))
+
+        # load
+        if sys.platform == "darwin":
+            print(cdll.LoadLibrary("libm.dylib"))
+            print(cdll.LoadLibrary("libcrypto.dylib"))
+            print(cdll.LoadLibrary("libSystem.dylib"))
+            print(cdll.LoadLibrary("System.framework/System"))
+        # issue-26439 - fix broken test call for AIX
+        elif sys.platform.startswith("aix"):
+            from ctypes import CDLL
+            if sys.maxsize < 2**32:
+                print(f"Using CDLL(name, os.RTLD_MEMBER): {CDLL('libc.a(shr.o)', os.RTLD_MEMBER)}")
+                print(f"Using cdll.LoadLibrary(): {cdll.LoadLibrary('libc.a(shr.o)')}")
+                # librpm.so is only available as 32-bit shared library
+                print(find_library("rpm"))
+                print(cdll.LoadLibrary("librpm.so"))
+            else:
+                print(f"Using CDLL(name, os.RTLD_MEMBER): {CDLL('libc.a(shr_64.o)', os.RTLD_MEMBER)}")
+                print(f"Using cdll.LoadLibrary(): {cdll.LoadLibrary('libc.a(shr_64.o)')}")
+            print(f"crypt\t:: {find_library('crypt')}")
+            print(f"crypt\t:: {cdll.LoadLibrary(find_library('crypt'))}")
+            print(f"crypto\t:: {find_library('crypto')}")
+            print(f"crypto\t:: {cdll.LoadLibrary(find_library('crypto'))}")
+        else:
+            print(cdll.LoadLibrary("libm.so"))
+            print(cdll.LoadLibrary("libcrypt.so"))
+            print(find_library("crypt"))
+
+if __name__ == "__main__":
+    test()
diff --git a/addon/globalPlugins/spellcheck/libs/_311/ctypes/wintypes.py b/addon/globalPlugins/spellcheck/libs/_311/ctypes/wintypes.py
new file mode 100644
index 0000000..c619d27
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/_311/ctypes/wintypes.py
@@ -0,0 +1,202 @@
+# The most useful windows datatypes
+import ctypes
+
+BYTE = ctypes.c_byte
+WORD = ctypes.c_ushort
+DWORD = ctypes.c_ulong
+
+#UCHAR = ctypes.c_uchar
+CHAR = ctypes.c_char
+WCHAR = ctypes.c_wchar
+UINT = ctypes.c_uint
+INT = ctypes.c_int
+
+DOUBLE = ctypes.c_double
+FLOAT = ctypes.c_float
+
+BOOLEAN = BYTE
+BOOL = ctypes.c_long
+
+class VARIANT_BOOL(ctypes._SimpleCData):
+    _type_ = "v"
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.value)
+
+ULONG = ctypes.c_ulong
+LONG = ctypes.c_long
+
+USHORT = ctypes.c_ushort
+SHORT = ctypes.c_short
+
+# in the windows header files, these are structures.
+_LARGE_INTEGER = LARGE_INTEGER = ctypes.c_longlong
+_ULARGE_INTEGER = ULARGE_INTEGER = ctypes.c_ulonglong
+
+LPCOLESTR = LPOLESTR = OLESTR = ctypes.c_wchar_p
+LPCWSTR = LPWSTR = ctypes.c_wchar_p
+LPCSTR = LPSTR = ctypes.c_char_p
+LPCVOID = LPVOID = ctypes.c_void_p
+
+# WPARAM is defined as UINT_PTR (unsigned type)
+# LPARAM is defined as LONG_PTR (signed type)
+if ctypes.sizeof(ctypes.c_long) == ctypes.sizeof(ctypes.c_void_p):
+    WPARAM = ctypes.c_ulong
+    LPARAM = ctypes.c_long
+elif ctypes.sizeof(ctypes.c_longlong) == ctypes.sizeof(ctypes.c_void_p):
+    WPARAM = ctypes.c_ulonglong
+    LPARAM = ctypes.c_longlong
+
+ATOM = WORD
+LANGID = WORD
+
+COLORREF = DWORD
+LGRPID = DWORD
+LCTYPE = DWORD
+
+LCID = DWORD
+
+################################################################
+# HANDLE types
+HANDLE = ctypes.c_void_p # in the header files: void *
+
+HACCEL = HANDLE
+HBITMAP = HANDLE
+HBRUSH = HANDLE
+HCOLORSPACE = HANDLE
+HDC = HANDLE
+HDESK = HANDLE
+HDWP = HANDLE
+HENHMETAFILE = HANDLE
+HFONT = HANDLE
+HGDIOBJ = HANDLE
+HGLOBAL = HANDLE
+HHOOK = HANDLE
+HICON = HANDLE
+HINSTANCE = HANDLE
+HKEY = HANDLE
+HKL = HANDLE
+HLOCAL = HANDLE
+HMENU = HANDLE
+HMETAFILE = HANDLE
+HMODULE = HANDLE
+HMONITOR = HANDLE
+HPALETTE = HANDLE
+HPEN = HANDLE
+HRGN = HANDLE
+HRSRC = HANDLE
+HSTR = HANDLE
+HTASK = HANDLE
+HWINSTA = HANDLE
+HWND = HANDLE
+SC_HANDLE = HANDLE
+SERVICE_STATUS_HANDLE = HANDLE
+
+################################################################
+# Some important structure definitions
+
+class RECT(ctypes.Structure):
+    _fields_ = [("left", LONG),
+                ("top", LONG),
+                ("right", LONG),
+                ("bottom", LONG)]
+tagRECT = _RECTL = RECTL = RECT
+
+class _SMALL_RECT(ctypes.Structure):
+    _fields_ = [('Left', SHORT),
+                ('Top', SHORT),
+                ('Right', SHORT),
+                ('Bottom', SHORT)]
+SMALL_RECT = _SMALL_RECT
+
+class _COORD(ctypes.Structure):
+    _fields_ = [('X', SHORT),
+                ('Y', SHORT)]
+
+class POINT(ctypes.Structure):
+    _fields_ = [("x", LONG),
+                ("y", LONG)]
+tagPOINT = _POINTL = POINTL = POINT
+
+class SIZE(ctypes.Structure):
+    _fields_ = [("cx", LONG),
+                ("cy", LONG)]
+tagSIZE = SIZEL = SIZE
+
+def RGB(red, green, blue):
+    return red + (green << 8) + (blue << 16)
+
+class FILETIME(ctypes.Structure):
+    _fields_ = [("dwLowDateTime", DWORD),
+                ("dwHighDateTime", DWORD)]
+_FILETIME = FILETIME
+
+class MSG(ctypes.Structure):
+    _fields_ = [("hWnd", HWND),
+                ("message", UINT),
+                ("wParam", WPARAM),
+                ("lParam", LPARAM),
+                ("time", DWORD),
+                ("pt", POINT)]
+tagMSG = MSG
+MAX_PATH = 260
+
+class WIN32_FIND_DATAA(ctypes.Structure):
+    _fields_ = [("dwFileAttributes", DWORD),
+                ("ftCreationTime", FILETIME),
+                ("ftLastAccessTime", FILETIME),
+                ("ftLastWriteTime", FILETIME),
+                ("nFileSizeHigh", DWORD),
+                ("nFileSizeLow", DWORD),
+                ("dwReserved0", DWORD),
+                ("dwReserved1", DWORD),
+                ("cFileName", CHAR * MAX_PATH),
+                ("cAlternateFileName", CHAR * 14)]
+
+class WIN32_FIND_DATAW(ctypes.Structure):
+    _fields_ = [("dwFileAttributes", DWORD),
+                ("ftCreationTime", FILETIME),
+                ("ftLastAccessTime", FILETIME),
+                ("ftLastWriteTime", FILETIME),
+                ("nFileSizeHigh", DWORD),
+                ("nFileSizeLow", DWORD),
+                ("dwReserved0", DWORD),
+                ("dwReserved1", DWORD),
+                ("cFileName", WCHAR * MAX_PATH),
+                ("cAlternateFileName", WCHAR * 14)]
+
+################################################################
+# Pointer types
+
+LPBOOL = PBOOL = ctypes.POINTER(BOOL)
+PBOOLEAN = ctypes.POINTER(BOOLEAN)
+LPBYTE = PBYTE = ctypes.POINTER(BYTE)
+PCHAR = ctypes.POINTER(CHAR)
+LPCOLORREF = ctypes.POINTER(COLORREF)
+LPDWORD = PDWORD = ctypes.POINTER(DWORD)
+LPFILETIME = PFILETIME = ctypes.POINTER(FILETIME)
+PFLOAT = ctypes.POINTER(FLOAT)
+LPHANDLE = PHANDLE = ctypes.POINTER(HANDLE)
+PHKEY = ctypes.POINTER(HKEY)
+LPHKL = ctypes.POINTER(HKL)
+LPINT = PINT = ctypes.POINTER(INT)
+PLARGE_INTEGER = ctypes.POINTER(LARGE_INTEGER)
+PLCID = ctypes.POINTER(LCID)
+LPLONG = PLONG = ctypes.POINTER(LONG)
+LPMSG = PMSG = ctypes.POINTER(MSG)
+LPPOINT = PPOINT = ctypes.POINTER(POINT)
+PPOINTL = ctypes.POINTER(POINTL)
+LPRECT = PRECT = ctypes.POINTER(RECT)
+LPRECTL = PRECTL = ctypes.POINTER(RECTL)
+LPSC_HANDLE = ctypes.POINTER(SC_HANDLE)
+PSHORT = ctypes.POINTER(SHORT)
+LPSIZE = PSIZE = ctypes.POINTER(SIZE)
+LPSIZEL = PSIZEL = ctypes.POINTER(SIZEL)
+PSMALL_RECT = ctypes.POINTER(SMALL_RECT)
+LPUINT = PUINT = ctypes.POINTER(UINT)
+PULARGE_INTEGER = ctypes.POINTER(ULARGE_INTEGER)
+PULONG = ctypes.POINTER(ULONG)
+PUSHORT = ctypes.POINTER(USHORT)
+PWCHAR = ctypes.POINTER(WCHAR)
+LPWIN32_FIND_DATAA = PWIN32_FIND_DATAA = ctypes.POINTER(WIN32_FIND_DATAA)
+LPWIN32_FIND_DATAW = PWIN32_FIND_DATAW = ctypes.POINTER(WIN32_FIND_DATAW)
+LPWORD = PWORD = ctypes.POINTER(WORD)
diff --git a/addon/globalPlugins/spellcheck/libs/_asyncio.pyd b/addon/globalPlugins/spellcheck/libs/_asyncio.pyd
deleted file mode 100644
index f78c1e7..0000000
Binary files a/addon/globalPlugins/spellcheck/libs/_asyncio.pyd and /dev/null differ
diff --git a/addon/globalPlugins/spellcheck/libs/_overlapped.pyd b/addon/globalPlugins/spellcheck/libs/_overlapped.pyd
deleted file mode 100644
index 8ce0a66..0000000
Binary files a/addon/globalPlugins/spellcheck/libs/_overlapped.pyd and /dev/null differ
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/__init__.py b/addon/globalPlugins/spellcheck/libs/anyio/__init__.py
index 5a34558..7bfe231 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/__init__.py
@@ -1,163 +1,76 @@
-__all__ = (
-    "maybe_async",
-    "maybe_async_cm",
-    "run",
-    "sleep",
-    "sleep_forever",
-    "sleep_until",
-    "current_time",
-    "get_all_backends",
-    "get_cancelled_exc_class",
-    "BrokenResourceError",
-    "BrokenWorkerProcess",
-    "BusyResourceError",
-    "ClosedResourceError",
-    "DelimiterNotFound",
-    "EndOfStream",
-    "ExceptionGroup",
-    "IncompleteRead",
-    "TypedAttributeLookupError",
-    "WouldBlock",
-    "AsyncFile",
-    "Path",
-    "open_file",
-    "wrap_file",
-    "aclose_forcefully",
-    "open_signal_receiver",
-    "connect_tcp",
-    "connect_unix",
-    "create_tcp_listener",
-    "create_unix_listener",
-    "create_udp_socket",
-    "create_connected_udp_socket",
-    "getaddrinfo",
-    "getnameinfo",
-    "wait_socket_readable",
-    "wait_socket_writable",
-    "create_memory_object_stream",
-    "run_process",
-    "open_process",
-    "create_lock",
-    "CapacityLimiter",
-    "CapacityLimiterStatistics",
-    "Condition",
-    "ConditionStatistics",
-    "Event",
-    "EventStatistics",
-    "Lock",
-    "LockStatistics",
-    "Semaphore",
-    "SemaphoreStatistics",
-    "create_condition",
-    "create_event",
-    "create_semaphore",
-    "create_capacity_limiter",
-    "open_cancel_scope",
-    "fail_after",
-    "move_on_after",
-    "current_effective_deadline",
-    "TASK_STATUS_IGNORED",
-    "CancelScope",
-    "create_task_group",
-    "TaskInfo",
-    "get_current_task",
-    "get_running_tasks",
-    "wait_all_tasks_blocked",
-    "run_sync_in_worker_thread",
-    "run_async_from_thread",
-    "run_sync_from_thread",
-    "current_default_worker_thread_limiter",
-    "create_blocking_portal",
-    "start_blocking_portal",
-    "typed_attribute",
-    "TypedAttributeSet",
-    "TypedAttributeProvider",
-)
+from __future__ import annotations
 
-from ._core._compat import maybe_async, maybe_async_cm
-from ._core._eventloop import (
-    current_time,
-    get_all_backends,
-    get_cancelled_exc_class,
-    run,
-    sleep,
-    sleep_forever,
-    sleep_until,
-)
-from ._core._exceptions import (
-    BrokenResourceError,
-    BrokenWorkerProcess,
-    BusyResourceError,
-    ClosedResourceError,
-    DelimiterNotFound,
-    EndOfStream,
-    ExceptionGroup,
-    IncompleteRead,
-    TypedAttributeLookupError,
-    WouldBlock,
-)
-from ._core._fileio import AsyncFile, Path, open_file, wrap_file
-from ._core._resources import aclose_forcefully
-from ._core._signals import open_signal_receiver
+from typing import Any
+
+from ._core._eventloop import current_time as current_time
+from ._core._eventloop import get_all_backends as get_all_backends
+from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class
+from ._core._eventloop import run as run
+from ._core._eventloop import sleep as sleep
+from ._core._eventloop import sleep_forever as sleep_forever
+from ._core._eventloop import sleep_until as sleep_until
+from ._core._exceptions import BrokenResourceError as BrokenResourceError
+from ._core._exceptions import BrokenWorkerProcess as BrokenWorkerProcess
+from ._core._exceptions import BusyResourceError as BusyResourceError
+from ._core._exceptions import ClosedResourceError as ClosedResourceError
+from ._core._exceptions import DelimiterNotFound as DelimiterNotFound
+from ._core._exceptions import EndOfStream as EndOfStream
+from ._core._exceptions import IncompleteRead as IncompleteRead
+from ._core._exceptions import TypedAttributeLookupError as TypedAttributeLookupError
+from ._core._exceptions import WouldBlock as WouldBlock
+from ._core._fileio import AsyncFile as AsyncFile
+from ._core._fileio import Path as Path
+from ._core._fileio import open_file as open_file
+from ._core._fileio import wrap_file as wrap_file
+from ._core._resources import aclose_forcefully as aclose_forcefully
+from ._core._signals import open_signal_receiver as open_signal_receiver
+from ._core._sockets import connect_tcp as connect_tcp
+from ._core._sockets import connect_unix as connect_unix
+from ._core._sockets import create_connected_udp_socket as create_connected_udp_socket
 from ._core._sockets import (
-    connect_tcp,
-    connect_unix,
-    create_connected_udp_socket,
-    create_tcp_listener,
-    create_udp_socket,
-    create_unix_listener,
-    getaddrinfo,
-    getnameinfo,
-    wait_socket_readable,
-    wait_socket_writable,
+    create_connected_unix_datagram_socket as create_connected_unix_datagram_socket,
 )
-from ._core._streams import create_memory_object_stream
-from ._core._subprocesses import open_process, run_process
+from ._core._sockets import create_tcp_listener as create_tcp_listener
+from ._core._sockets import create_udp_socket as create_udp_socket
+from ._core._sockets import create_unix_datagram_socket as create_unix_datagram_socket
+from ._core._sockets import create_unix_listener as create_unix_listener
+from ._core._sockets import getaddrinfo as getaddrinfo
+from ._core._sockets import getnameinfo as getnameinfo
+from ._core._sockets import wait_socket_readable as wait_socket_readable
+from ._core._sockets import wait_socket_writable as wait_socket_writable
+from ._core._streams import create_memory_object_stream as create_memory_object_stream
+from ._core._subprocesses import open_process as open_process
+from ._core._subprocesses import run_process as run_process
+from ._core._synchronization import CapacityLimiter as CapacityLimiter
 from ._core._synchronization import (
-    CapacityLimiter,
-    CapacityLimiterStatistics,
-    Condition,
-    ConditionStatistics,
-    Event,
-    EventStatistics,
-    Lock,
-    LockStatistics,
-    Semaphore,
-    SemaphoreStatistics,
-    create_capacity_limiter,
-    create_condition,
-    create_event,
-    create_lock,
-    create_semaphore,
-)
-from ._core._tasks import (
-    TASK_STATUS_IGNORED,
-    CancelScope,
-    create_task_group,
-    current_effective_deadline,
-    fail_after,
-    move_on_after,
-    open_cancel_scope,
-)
-from ._core._testing import (
-    TaskInfo,
-    get_current_task,
-    get_running_tasks,
-    wait_all_tasks_blocked,
-)
-from ._core._typedattr import TypedAttributeProvider, TypedAttributeSet, typed_attribute
-
-# Re-exported here, for backwards compatibility
-# isort: off
-from .to_thread import current_default_worker_thread_limiter, run_sync_in_worker_thread
-from .from_thread import (
-    create_blocking_portal,
-    run_async_from_thread,
-    run_sync_from_thread,
-    start_blocking_portal,
+    CapacityLimiterStatistics as CapacityLimiterStatistics,
 )
+from ._core._synchronization import Condition as Condition
+from ._core._synchronization import ConditionStatistics as ConditionStatistics
+from ._core._synchronization import Event as Event
+from ._core._synchronization import EventStatistics as EventStatistics
+from ._core._synchronization import Lock as Lock
+from ._core._synchronization import LockStatistics as LockStatistics
+from ._core._synchronization import ResourceGuard as ResourceGuard
+from ._core._synchronization import Semaphore as Semaphore
+from ._core._synchronization import SemaphoreStatistics as SemaphoreStatistics
+from ._core._tasks import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED
+from ._core._tasks import CancelScope as CancelScope
+from ._core._tasks import create_task_group as create_task_group
+from ._core._tasks import current_effective_deadline as current_effective_deadline
+from ._core._tasks import fail_after as fail_after
+from ._core._tasks import move_on_after as move_on_after
+from ._core._testing import TaskInfo as TaskInfo
+from ._core._testing import get_current_task as get_current_task
+from ._core._testing import get_running_tasks as get_running_tasks
+from ._core._testing import wait_all_tasks_blocked as wait_all_tasks_blocked
+from ._core._typedattr import TypedAttributeProvider as TypedAttributeProvider
+from ._core._typedattr import TypedAttributeSet as TypedAttributeSet
+from ._core._typedattr import typed_attribute as typed_attribute
 
 # Re-export imports so they look like they live directly in this package
+key: str
+value: Any
 for key, value in list(locals().items()):
     if getattr(value, "__module__", "").startswith("anyio."):
         value.__module__ = __name__
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_backends/_asyncio.py b/addon/globalPlugins/spellcheck/libs/anyio/_backends/_asyncio.py
index 504067f..2699bf8 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_backends/_asyncio.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_backends/_asyncio.py
@@ -1,180 +1,287 @@
+from __future__ import annotations
+
 import array
 import asyncio
 import concurrent.futures
 import math
 import socket
 import sys
-from asyncio.base_events import _run_until_complete_cb  # type: ignore
+import threading
+from asyncio import (
+    AbstractEventLoop,
+    CancelledError,
+    all_tasks,
+    create_task,
+    current_task,
+    get_running_loop,
+    sleep,
+)
+from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
 from collections import OrderedDict, deque
+from collections.abc import AsyncIterator, Generator, Iterable
 from concurrent.futures import Future
+from contextlib import suppress
+from contextvars import Context, copy_context
 from dataclasses import dataclass
 from functools import partial, wraps
 from inspect import (
     CORO_RUNNING,
     CORO_SUSPENDED,
-    GEN_RUNNING,
-    GEN_SUSPENDED,
     getcoroutinestate,
-    getgeneratorstate,
+    iscoroutine,
 )
 from io import IOBase
 from os import PathLike
 from queue import Queue
+from signal import Signals
 from socket import AddressFamily, SocketKind
 from threading import Thread
 from types import TracebackType
 from typing import (
+    IO,
     Any,
+    AsyncGenerator,
     Awaitable,
     Callable,
     Collection,
+    ContextManager,
     Coroutine,
-    Deque,
-    Dict,
-    Generator,
-    Iterable,
-    List,
     Mapping,
     Optional,
     Sequence,
-    Set,
     Tuple,
-    Type,
     TypeVar,
-    Union,
     cast,
 )
 from weakref import WeakKeyDictionary
 
+import sniffio
+
 from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
-from .._core._compat import DeprecatedAsyncContextManager, DeprecatedAwaitable
 from .._core._eventloop import claim_worker_thread, threadlocals
 from .._core._exceptions import (
     BrokenResourceError,
     BusyResourceError,
     ClosedResourceError,
     EndOfStream,
+    WouldBlock,
 )
-from .._core._exceptions import ExceptionGroup as BaseExceptionGroup
-from .._core._exceptions import WouldBlock
-from .._core._sockets import GetAddrInfoReturnType, convert_ipv6_sockaddr
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._streams import create_memory_object_stream
 from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
 from .._core._synchronization import Event as BaseEvent
 from .._core._synchronization import ResourceGuard
 from .._core._tasks import CancelScope as BaseCancelScope
-from ..abc import IPSockAddrType, UDPPacketType
+from ..abc import (
+    AsyncBackend,
+    IPSockAddrType,
+    SocketListener,
+    UDPPacketType,
+    UNIXDatagramPacketType,
+)
 from ..lowlevel import RunVar
+from ..streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
-if sys.version_info >= (3, 8):
-    get_coro = asyncio.Task.get_coro
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
 else:
+    from typing_extensions import ParamSpec
 
-    def get_coro(task: asyncio.Task) -> Union[Coroutine, Generator]:
-        return task._coro
-
-
-if sys.version_info >= (3, 7):
-    from asyncio import all_tasks, create_task, current_task, get_running_loop
-    from asyncio import run as native_run
-
-    def _get_task_callbacks(task: asyncio.Task) -> Iterable[Callable]:
-        return [cb for cb, context in task._callbacks]  # type: ignore
-
-
+if sys.version_info >= (3, 11):
+    from asyncio import Runner
+    from typing import TypeVarTuple, Unpack
 else:
-    _T = TypeVar("_T")
-
-    def _get_task_callbacks(task: asyncio.Task) -> Iterable[Callable]:
-        return task._callbacks
-
-    def native_run(main, *, debug=False):
-        # Snatched from Python 3.7
-        from asyncio import coroutines, events, tasks
+    import contextvars
+    import enum
+    import signal
+    from asyncio import coroutines, events, exceptions, tasks
+
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import TypeVarTuple, Unpack
+
+    class _State(enum.Enum):
+        CREATED = "created"
+        INITIALIZED = "initialized"
+        CLOSED = "closed"
+
+    class Runner:
+        # Copied from CPython 3.11
+        def __init__(
+            self,
+            *,
+            debug: bool | None = None,
+            loop_factory: Callable[[], AbstractEventLoop] | None = None,
+        ):
+            self._state = _State.CREATED
+            self._debug = debug
+            self._loop_factory = loop_factory
+            self._loop: AbstractEventLoop | None = None
+            self._context = None
+            self._interrupt_count = 0
+            self._set_event_loop = False
+
+        def __enter__(self) -> Runner:
+            self._lazy_init()
+            return self
+
+        def __exit__(
+            self,
+            exc_type: type[BaseException],
+            exc_val: BaseException,
+            exc_tb: TracebackType,
+        ) -> None:
+            self.close()
 
-        def _cancel_all_tasks(loop):
-            to_cancel = all_tasks(loop)
-            if not to_cancel:
+        def close(self) -> None:
+            """Shutdown and close event loop."""
+            if self._state is not _State.INITIALIZED:
                 return
+            try:
+                loop = self._loop
+                _cancel_all_tasks(loop)
+                loop.run_until_complete(loop.shutdown_asyncgens())
+                if hasattr(loop, "shutdown_default_executor"):
+                    loop.run_until_complete(loop.shutdown_default_executor())
+                else:
+                    loop.run_until_complete(_shutdown_default_executor(loop))
+            finally:
+                if self._set_event_loop:
+                    events.set_event_loop(None)
+                loop.close()
+                self._loop = None
+                self._state = _State.CLOSED
 
-            for task in to_cancel:
-                task.cancel()
+        def get_loop(self) -> AbstractEventLoop:
+            """Return embedded event loop."""
+            self._lazy_init()
+            return self._loop
 
-            loop.run_until_complete(
-                tasks.gather(*to_cancel, loop=loop, return_exceptions=True)
-            )
+        def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval:
+            """Run a coroutine inside the embedded event loop."""
+            if not coroutines.iscoroutine(coro):
+                raise ValueError(f"a coroutine was expected, got {coro!r}")
 
-            for task in to_cancel:
-                if task.cancelled():
-                    continue
-                if task.exception() is not None:
-                    loop.call_exception_handler(
-                        {
-                            "message": "unhandled exception during asyncio.run() shutdown",
-                            "exception": task.exception(),
-                            "task": task,
-                        }
-                    )
+            if events._get_running_loop() is not None:
+                # fail fast with short traceback
+                raise RuntimeError(
+                    "Runner.run() cannot be called from a running event loop"
+                )
 
-        if events._get_running_loop() is not None:
-            raise RuntimeError(
-                "asyncio.run() cannot be called from a running event loop"
-            )
+            self._lazy_init()
 
-        if not coroutines.iscoroutine(main):
-            raise ValueError("a coroutine was expected, got {!r}".format(main))
+            if context is None:
+                context = self._context
+            task = context.run(self._loop.create_task, coro)
 
-        loop = events.new_event_loop()
-        try:
-            events.set_event_loop(loop)
-            loop.set_debug(debug)
-            return loop.run_until_complete(main)
-        finally:
+            if (
+                threading.current_thread() is threading.main_thread()
+                and signal.getsignal(signal.SIGINT) is signal.default_int_handler
+            ):
+                sigint_handler = partial(self._on_sigint, main_task=task)
+                try:
+                    signal.signal(signal.SIGINT, sigint_handler)
+                except ValueError:
+                    # `signal.signal` may throw if `threading.main_thread` does
+                    # not support signals (e.g. embedded interpreter with signals
+                    # not registered - see gh-91880)
+                    sigint_handler = None
+            else:
+                sigint_handler = None
+
+            self._interrupt_count = 0
             try:
-                _cancel_all_tasks(loop)
-                loop.run_until_complete(loop.shutdown_asyncgens())
+                return self._loop.run_until_complete(task)
+            except exceptions.CancelledError:
+                if self._interrupt_count > 0:
+                    uncancel = getattr(task, "uncancel", None)
+                    if uncancel is not None and uncancel() == 0:
+                        raise KeyboardInterrupt()
+                raise  # CancelledError
             finally:
-                events.set_event_loop(None)
-                loop.close()
-
-    def create_task(
-        coro: Union[Generator[Any, None, _T], Awaitable[_T]], *, name: object = None
-    ) -> asyncio.Task:
-        return get_running_loop().create_task(coro)
+                if (
+                    sigint_handler is not None
+                    and signal.getsignal(signal.SIGINT) is sigint_handler
+                ):
+                    signal.signal(signal.SIGINT, signal.default_int_handler)
 
-    def get_running_loop() -> asyncio.AbstractEventLoop:
-        loop = asyncio._get_running_loop()
-        if loop is not None:
-            return loop
-        else:
-            raise RuntimeError("no running event loop")
+        def _lazy_init(self) -> None:
+            if self._state is _State.CLOSED:
+                raise RuntimeError("Runner is closed")
+            if self._state is _State.INITIALIZED:
+                return
+            if self._loop_factory is None:
+                self._loop = events.new_event_loop()
+                if not self._set_event_loop:
+                    # Call set_event_loop only once to avoid calling
+                    # attach_loop multiple times on child watchers
+                    events.set_event_loop(self._loop)
+                    self._set_event_loop = True
+            else:
+                self._loop = self._loop_factory()
+            if self._debug is not None:
+                self._loop.set_debug(self._debug)
+            self._context = contextvars.copy_context()
+            self._state = _State.INITIALIZED
+
+        def _on_sigint(self, signum, frame, main_task: asyncio.Task) -> None:
+            self._interrupt_count += 1
+            if self._interrupt_count == 1 and not main_task.done():
+                main_task.cancel()
+                # wakeup loop if it is blocked by select() with long timeout
+                self._loop.call_soon_threadsafe(lambda: None)
+                return
+            raise KeyboardInterrupt()
 
-    def all_tasks(
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> Set[asyncio.Task]:
-        """Return a set of all tasks for the loop."""
-        from asyncio import Task
+    def _cancel_all_tasks(loop: AbstractEventLoop) -> None:
+        to_cancel = tasks.all_tasks(loop)
+        if not to_cancel:
+            return
 
-        if loop is None:
-            loop = get_running_loop()
+        for task in to_cancel:
+            task.cancel()
 
-        return {t for t in Task.all_tasks(loop) if not t.done()}
+        loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True))
 
-    def current_task(
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> Optional[asyncio.Task]:
-        if loop is None:
-            loop = get_running_loop()
+        for task in to_cancel:
+            if task.cancelled():
+                continue
+            if task.exception() is not None:
+                loop.call_exception_handler(
+                    {
+                        "message": "unhandled exception during asyncio.run() shutdown",
+                        "exception": task.exception(),
+                        "task": task,
+                    }
+                )
 
-        return asyncio.Task.current_task(loop)
+    async def _shutdown_default_executor(loop: AbstractEventLoop) -> None:
+        """Schedule the shutdown of the default executor."""
 
+        def _do_shutdown(future: asyncio.futures.Future) -> None:
+            try:
+                loop._default_executor.shutdown(wait=True)  # type: ignore[attr-defined]
+                loop.call_soon_threadsafe(future.set_result, None)
+            except Exception as ex:
+                loop.call_soon_threadsafe(future.set_exception, ex)
 
-T_Retval = TypeVar("T_Retval")
+        loop._executor_shutdown_called = True
+        if loop._default_executor is None:
+            return
+        future = loop.create_future()
+        thread = threading.Thread(target=_do_shutdown, args=(future,))
+        thread.start()
+        try:
+            await future
+        finally:
+            thread.join()
 
-# Check whether there is native support for task names in asyncio (3.8+)
-_native_task_names = hasattr(asyncio.Task, "get_name")
 
+T_Retval = TypeVar("T_Retval")
+T_contra = TypeVar("T_contra", contravariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
+P = ParamSpec("P")
 
-_root_task: RunVar[Optional[asyncio.Task]] = RunVar("_root_task")
+_root_task: RunVar[asyncio.Task | None] = RunVar("_root_task")
 
 
 def find_root_task() -> asyncio.Task:
@@ -185,7 +292,8 @@ def find_root_task() -> asyncio.Task:
     # Look for a task that has been started via run_until_complete()
     for task in all_tasks():
         if task._callbacks and not task.done():
-            for cb in _get_task_callbacks(task):
+            callbacks = [cb for cb, context in task._callbacks]
+            for cb in callbacks:
                 if (
                     cb is _run_until_complete_cb
                     or getattr(cb, "__module__", None) == "uvloop.loop"
@@ -217,104 +325,45 @@ def get_callable_name(func: Callable) -> str:
 # Event loop
 #
 
-_run_vars = (
-    WeakKeyDictionary()
-)  # type: WeakKeyDictionary[asyncio.AbstractEventLoop, Any]
-
-current_token = get_running_loop
+_run_vars: WeakKeyDictionary[asyncio.AbstractEventLoop, Any] = WeakKeyDictionary()
 
 
 def _task_started(task: asyncio.Task) -> bool:
     """Return ``True`` if the task has been started and has not finished."""
-    coro = get_coro(task)
     try:
-        return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED)
+        return getcoroutinestate(task.get_coro()) in (CORO_RUNNING, CORO_SUSPENDED)
     except AttributeError:
-        try:
-            return getgeneratorstate(coro) in (GEN_RUNNING, GEN_SUSPENDED)
-        except AttributeError:
-            # task coro is async_genenerator_asend https://bugs.python.org/issue37771
-            raise Exception(f"Cannot determine if task {task} has started or not")
-
-
-def _maybe_set_event_loop_policy(
-    policy: Optional[asyncio.AbstractEventLoopPolicy], use_uvloop: bool
-) -> None:
-    # On CPython, use uvloop when possible if no other policy has been given and if not
-    # explicitly disabled
-    if policy is None and use_uvloop and sys.implementation.name == "cpython":
-        try:
-            import uvloop
-        except ImportError:
-            pass
-        else:
-            # Test for missing shutdown_default_executor() (uvloop 0.14.0 and earlier)
-            if not hasattr(
-                asyncio.AbstractEventLoop, "shutdown_default_executor"
-            ) or hasattr(uvloop.loop.Loop, "shutdown_default_executor"):
-                policy = uvloop.EventLoopPolicy()
-
-    if policy is not None:
-        asyncio.set_event_loop_policy(policy)
-
-
-def run(
-    func: Callable[..., Awaitable[T_Retval]],
-    *args: object,
-    debug: bool = False,
-    use_uvloop: bool = False,
-    policy: Optional[asyncio.AbstractEventLoopPolicy] = None,
-) -> T_Retval:
-    @wraps(func)
-    async def wrapper() -> T_Retval:
-        task = cast(asyncio.Task, current_task())
-        task_state = TaskState(None, get_callable_name(func), None)
-        _task_states[task] = task_state
-        if _native_task_names:
-            task.set_name(task_state.name)
-
-        try:
-            return await func(*args)
-        finally:
-            del _task_states[task]
-
-    _maybe_set_event_loop_policy(policy, use_uvloop)
-    return native_run(wrapper(), debug=debug)
-
-
-#
-# Miscellaneous
-#
-
-sleep = asyncio.sleep
+        # task coro is async_genenerator_asend https://bugs.python.org/issue37771
+        raise Exception(f"Cannot determine if task {task} has started or not") from None
 
 
 #
 # Timeouts and cancellation
 #
 
-CancelledError = asyncio.CancelledError
-
 
 class CancelScope(BaseCancelScope):
     def __new__(
         cls, *, deadline: float = math.inf, shield: bool = False
-    ) -> "CancelScope":
+    ) -> CancelScope:
         return object.__new__(cls)
 
     def __init__(self, deadline: float = math.inf, shield: bool = False):
         self._deadline = deadline
         self._shield = shield
-        self._parent_scope: Optional[CancelScope] = None
+        self._parent_scope: CancelScope | None = None
+        self._child_scopes: set[CancelScope] = set()
         self._cancel_called = False
+        self._cancelled_caught = False
         self._active = False
-        self._timeout_handle: Optional[asyncio.TimerHandle] = None
-        self._cancel_handle: Optional[asyncio.Handle] = None
-        self._tasks: Set[asyncio.Task] = set()
-        self._host_task: Optional[asyncio.Task] = None
-        self._timeout_expired = False
-
-    def __enter__(self) -> "CancelScope":
+        self._timeout_handle: asyncio.TimerHandle | None = None
+        self._cancel_handle: asyncio.Handle | None = None
+        self._tasks: set[asyncio.Task] = set()
+        self._host_task: asyncio.Task | None = None
+        self._cancel_calls: int = 0
+        self._cancelling: int | None = None
+
+    def __enter__(self) -> CancelScope:
         if self._active:
             raise RuntimeError(
                 "Each CancelScope may only be used for a single 'with' block"
@@ -325,23 +374,32 @@ def __enter__(self) -> "CancelScope":
         try:
             task_state = _task_states[host_task]
         except KeyError:
-            task_name = host_task.get_name() if _native_task_names else None
-            task_state = TaskState(None, task_name, self)
+            task_state = TaskState(None, self)
             _task_states[host_task] = task_state
         else:
             self._parent_scope = task_state.cancel_scope
             task_state.cancel_scope = self
+            if self._parent_scope is not None:
+                self._parent_scope._child_scopes.add(self)
+                self._parent_scope._tasks.remove(host_task)
 
         self._timeout()
         self._active = True
+        if sys.version_info >= (3, 11):
+            self._cancelling = self._host_task.cancelling()
+
+        # Start cancelling the host task if the scope was cancelled before entering
+        if self._cancel_called:
+            self._deliver_cancellation(self)
+
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         if not self._active:
             raise RuntimeError("This cancel scope is not active")
         if current_task() is not self._host_task:
@@ -364,80 +422,106 @@ def __exit__(
             self._timeout_handle = None
 
         self._tasks.remove(self._host_task)
+        if self._parent_scope is not None:
+            self._parent_scope._child_scopes.remove(self)
+            self._parent_scope._tasks.add(self._host_task)
 
         host_task_state.cancel_scope = self._parent_scope
 
-        # Restart the cancellation effort in the nearest directly cancelled parent scope if this
-        # one was shielded
-        if self._shield:
-            self._deliver_cancellation_to_parent()
+        # Restart the cancellation effort in the closest directly cancelled parent
+        # scope if this one was shielded
+        self._restart_cancellation_in_parent()
 
-        if exc_val is not None:
-            exceptions = (
-                exc_val.exceptions if isinstance(exc_val, ExceptionGroup) else [exc_val]
-            )
-            if all(isinstance(exc, CancelledError) for exc in exceptions):
-                if self._timeout_expired:
-                    return True
-                elif not self._cancel_called:
-                    # Task was cancelled natively
-                    return None
-                elif not self._parent_cancelled():
-                    # This scope was directly cancelled
-                    return True
+        if self._cancel_called and exc_val is not None:
+            for exc in iterate_exceptions(exc_val):
+                if isinstance(exc, CancelledError):
+                    self._cancelled_caught = self._uncancel(exc)
+                    if self._cancelled_caught:
+                        break
+
+            return self._cancelled_caught
 
         return None
 
+    def _uncancel(self, cancelled_exc: CancelledError) -> bool:
+        if sys.version_info < (3, 9) or self._host_task is None:
+            self._cancel_calls = 0
+            return True
+
+        # Undo all cancellations done by this scope
+        if self._cancelling is not None:
+            while self._cancel_calls:
+                self._cancel_calls -= 1
+                if self._host_task.uncancel() <= self._cancelling:
+                    return True
+
+        self._cancel_calls = 0
+        return f"Cancelled by cancel scope {id(self):x}" in cancelled_exc.args
+
     def _timeout(self) -> None:
         if self._deadline != math.inf:
             loop = get_running_loop()
             if loop.time() >= self._deadline:
-                self._timeout_expired = True
                 self.cancel()
             else:
                 self._timeout_handle = loop.call_at(self._deadline, self._timeout)
 
-    def _deliver_cancellation(self) -> None:
+    def _deliver_cancellation(self, origin: CancelScope) -> bool:
         """
         Deliver cancellation to directly contained tasks and nested cancel scopes.
 
-        Schedule another run at the end if we still have tasks eligible for cancellation.
+        Schedule another run at the end if we still have tasks eligible for
+        cancellation.
+
+        :param origin: the cancel scope that originated the cancellation
+        :return: ``True`` if the delivery needs to be retried on the next cycle
+
         """
         should_retry = False
         current = current_task()
         for task in self._tasks:
-            if task._must_cancel:  # type: ignore
+            if task._must_cancel:  # type: ignore[attr-defined]
                 continue
 
-            # The task is eligible for cancellation if it has started and is not in a cancel
-            # scope shielded from this one
-            cancel_scope = _task_states[task].cancel_scope
-            while cancel_scope is not self:
-                if cancel_scope is None or cancel_scope._shield:
-                    break
-                else:
-                    cancel_scope = cancel_scope._parent_scope
-            else:
-                should_retry = True
-                if task is not current and (
-                    task is self._host_task or _task_started(task)
-                ):
-                    task.cancel()
+            # The task is eligible for cancellation if it has started
+            should_retry = True
+            if task is not current and (task is self._host_task or _task_started(task)):
+                waiter = task._fut_waiter  # type: ignore[attr-defined]
+                if not isinstance(waiter, asyncio.Future) or not waiter.done():
+                    self._cancel_calls += 1
+                    if sys.version_info >= (3, 9):
+                        task.cancel(f"Cancelled by cancel scope {id(origin):x}")
+                    else:
+                        task.cancel()
+
+        # Deliver cancellation to child scopes that aren't shielded or running their own
+        # cancellation callbacks
+        for scope in self._child_scopes:
+            if not scope._shield and not scope.cancel_called:
+                should_retry = scope._deliver_cancellation(origin) or should_retry
 
         # Schedule another callback if there are still tasks left
-        if should_retry:
-            self._cancel_handle = get_running_loop().call_soon(
-                self._deliver_cancellation
-            )
-        else:
-            self._cancel_handle = None
+        if origin is self:
+            if should_retry:
+                self._cancel_handle = get_running_loop().call_soon(
+                    self._deliver_cancellation, origin
+                )
+            else:
+                self._cancel_handle = None
+
+        return should_retry
+
+    def _restart_cancellation_in_parent(self) -> None:
+        """
+        Restart the cancellation effort in the closest directly cancelled parent scope.
 
-    def _deliver_cancellation_to_parent(self) -> None:
-        """Start cancellation effort in the nearest directly cancelled parent scope"""
+        """
         scope = self._parent_scope
         while scope is not None:
-            if scope._cancel_called and scope._cancel_handle is None:
-                scope._deliver_cancellation()
+            if scope._cancel_called:
+                if scope._cancel_handle is None:
+                    scope._deliver_cancellation(scope)
+
                 break
 
             # No point in looking beyond any shielded scope
@@ -457,16 +541,15 @@ def _parent_cancelled(self) -> bool:
 
         return False
 
-    def cancel(self) -> DeprecatedAwaitable:
+    def cancel(self) -> None:
         if not self._cancel_called:
             if self._timeout_handle:
                 self._timeout_handle.cancel()
                 self._timeout_handle = None
 
             self._cancel_called = True
-            self._deliver_cancellation()
-
-        return DeprecatedAwaitable(self.cancel)
+            if self._host_task is not None:
+                self._deliver_cancellation(self)
 
     @property
     def deadline(self) -> float:
@@ -486,6 +569,10 @@ def deadline(self, value: float) -> None:
     def cancel_called(self) -> bool:
         return self._cancel_called
 
+    @property
+    def cancelled_caught(self) -> bool:
+        return self._cancelled_caught
+
     @property
     def shield(self) -> bool:
         return self._shield
@@ -495,56 +582,7 @@ def shield(self, value: bool) -> None:
         if self._shield != value:
             self._shield = value
             if not value:
-                self._deliver_cancellation_to_parent()
-
-
-async def checkpoint() -> None:
-    await sleep(0)
-
-
-async def checkpoint_if_cancelled() -> None:
-    task = current_task()
-    if task is None:
-        return
-
-    try:
-        cancel_scope = _task_states[task].cancel_scope
-    except KeyError:
-        return
-
-    while cancel_scope:
-        if cancel_scope.cancel_called:
-            await sleep(0)
-        elif cancel_scope.shield:
-            break
-        else:
-            cancel_scope = cancel_scope._parent_scope
-
-
-async def cancel_shielded_checkpoint() -> None:
-    with CancelScope(shield=True):
-        await sleep(0)
-
-
-def current_effective_deadline() -> float:
-    try:
-        cancel_scope = _task_states[current_task()].cancel_scope  # type: ignore[index]
-    except KeyError:
-        return math.inf
-
-    deadline = math.inf
-    while cancel_scope:
-        deadline = min(deadline, cancel_scope.deadline)
-        if cancel_scope.shield:
-            break
-        else:
-            cancel_scope = cancel_scope._parent_scope
-
-    return deadline
-
-
-def current_time() -> float:
-    return get_running_loop().time()
+                self._restart_cancellation_in_parent()
 
 
 #
@@ -554,20 +592,14 @@ def current_time() -> float:
 
 class TaskState:
     """
-    Encapsulates auxiliary task information that cannot be added to the Task instance itself
-    because there are no guarantees about its implementation.
+    Encapsulates auxiliary task information that cannot be added to the Task instance
+    itself because there are no guarantees about its implementation.
     """
 
-    __slots__ = "parent_id", "name", "cancel_scope"
+    __slots__ = "parent_id", "cancel_scope"
 
-    def __init__(
-        self,
-        parent_id: Optional[int],
-        name: Optional[str],
-        cancel_scope: Optional[CancelScope],
-    ):
+    def __init__(self, parent_id: int | None, cancel_scope: CancelScope | None):
         self.parent_id = parent_id
-        self.name = name
         self.cancel_scope = cancel_scope
 
 
@@ -579,17 +611,12 @@ def __init__(
 #
 
 
-class ExceptionGroup(BaseExceptionGroup):
-    def __init__(self, exceptions: Sequence[BaseException]):
-        super().__init__()
-        self.exceptions = exceptions
-
-
 class _AsyncioTaskStatus(abc.TaskStatus):
-    def __init__(self, future: asyncio.Future):
+    def __init__(self, future: asyncio.Future, parent_id: int):
         self._future = future
+        self._parent_id = parent_id
 
-    def started(self, value: object = None) -> None:
+    def started(self, value: T_contra | None = None) -> None:
         try:
             self._future.set_result(value)
         except asyncio.InvalidStateError:
@@ -597,119 +624,84 @@ def started(self, value: object = None) -> None:
                 "called 'started' twice on the same task status"
             ) from None
 
+        task = cast(asyncio.Task, current_task())
+        _task_states[task].parent_id = self._parent_id
+
+
+def iterate_exceptions(
+    exception: BaseException,
+) -> Generator[BaseException, None, None]:
+    if isinstance(exception, BaseExceptionGroup):
+        for exc in exception.exceptions:
+            yield from iterate_exceptions(exc)
+    else:
+        yield exception
+
 
 class TaskGroup(abc.TaskGroup):
     def __init__(self) -> None:
         self.cancel_scope: CancelScope = CancelScope()
         self._active = False
-        self._exceptions: List[BaseException] = []
+        self._exceptions: list[BaseException] = []
+        self._tasks: set[asyncio.Task] = set()
 
-    async def __aenter__(self) -> "TaskGroup":
+    async def __aenter__(self) -> TaskGroup:
         self.cancel_scope.__enter__()
         self._active = True
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         ignore_exception = self.cancel_scope.__exit__(exc_type, exc_val, exc_tb)
         if exc_val is not None:
             self.cancel_scope.cancel()
-            self._exceptions.append(exc_val)
+            if not isinstance(exc_val, CancelledError):
+                self._exceptions.append(exc_val)
 
-        while self.cancel_scope._tasks:
+        cancelled_exc_while_waiting_tasks: CancelledError | None = None
+        while self._tasks:
             try:
-                await asyncio.wait(self.cancel_scope._tasks)
-            except asyncio.CancelledError:
+                await asyncio.wait(self._tasks)
+            except CancelledError as exc:
+                # This task was cancelled natively; reraise the CancelledError later
+                # unless this task was already interrupted by another exception
                 self.cancel_scope.cancel()
+                if cancelled_exc_while_waiting_tasks is None:
+                    cancelled_exc_while_waiting_tasks = exc
 
         self._active = False
-        if not self.cancel_scope._parent_cancelled():
-            exceptions = self._filter_cancellation_errors(self._exceptions)
-        else:
-            exceptions = self._exceptions
+        if self._exceptions:
+            raise BaseExceptionGroup(
+                "unhandled errors in a TaskGroup", self._exceptions
+            )
 
-        try:
-            if len(exceptions) > 1:
-                if all(
-                    isinstance(e, CancelledError) and not e.args for e in exceptions
-                ):
-                    # Tasks were cancelled natively, without a cancellation message
-                    raise CancelledError
-                else:
-                    raise ExceptionGroup(exceptions)
-            elif exceptions and exceptions[0] is not exc_val:
-                raise exceptions[0]
-        except BaseException as exc:
-            # Clear the context here, as it can only be done in-flight.
-            # If the context is not cleared, it can result in recursive tracebacks (see #145).
-            exc.__context__ = None
-            raise
+        # Raise the CancelledError received while waiting for child tasks to exit,
+        # unless the context manager itself was previously exited with another
+        # exception, or if any of the  child tasks raised an exception other than
+        # CancelledError
+        if cancelled_exc_while_waiting_tasks:
+            if exc_val is None or ignore_exception:
+                raise cancelled_exc_while_waiting_tasks
 
         return ignore_exception
 
-    @staticmethod
-    def _filter_cancellation_errors(
-        exceptions: Sequence[BaseException],
-    ) -> List[BaseException]:
-        filtered_exceptions: List[BaseException] = []
-        for exc in exceptions:
-            if isinstance(exc, ExceptionGroup):
-                new_exceptions = TaskGroup._filter_cancellation_errors(exc.exceptions)
-                if len(new_exceptions) > 1:
-                    filtered_exceptions.append(exc)
-                elif len(new_exceptions) == 1:
-                    filtered_exceptions.append(new_exceptions[0])
-                elif new_exceptions:
-                    new_exc = ExceptionGroup(new_exceptions)
-                    new_exc.__cause__ = exc.__cause__
-                    new_exc.__context__ = exc.__context__
-                    new_exc.__traceback__ = exc.__traceback__
-                    filtered_exceptions.append(new_exc)
-            elif not isinstance(exc, CancelledError) or exc.args:
-                filtered_exceptions.append(exc)
-
-        return filtered_exceptions
-
-    async def _run_wrapped_task(
-        self, coro: Coroutine, task_status_future: Optional[asyncio.Future]
-    ) -> None:
-        # This is the code path for Python 3.6 and 3.7 on which asyncio freaks out if a task raises
-        # a BaseException.
-        __traceback_hide__ = __tracebackhide__ = True  # noqa: F841
-        task = cast(asyncio.Task, current_task())
-        try:
-            await coro
-        except BaseException as exc:
-            if task_status_future is None or task_status_future.done():
-                self._exceptions.append(exc)
-                self.cancel_scope.cancel()
-            else:
-                task_status_future.set_exception(exc)
-        else:
-            if task_status_future is not None and not task_status_future.done():
-                task_status_future.set_exception(
-                    RuntimeError("Child exited without calling task_status.started()")
-                )
-        finally:
-            if task in self.cancel_scope._tasks:
-                self.cancel_scope._tasks.remove(task)
-                del _task_states[task]
-
     def _spawn(
         self,
-        func: Callable[..., Coroutine],
-        args: tuple,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[Any]],
+        args: tuple[Unpack[PosArgsT]],
         name: object,
-        task_status_future: Optional[asyncio.Future] = None,
+        task_status_future: asyncio.Future | None = None,
     ) -> asyncio.Task:
         def task_done(_task: asyncio.Task) -> None:
-            # This is the code path for Python 3.8+
-            assert _task in self.cancel_scope._tasks
-            self.cancel_scope._tasks.remove(_task)
+            task_state = _task_states[_task]
+            assert task_state.cancel_scope is not None
+            assert _task in task_state.cancel_scope._tasks
+            task_state.cancel_scope._tasks.remove(_task)
+            self._tasks.remove(task)
             del _task_states[_task]
 
             try:
@@ -722,8 +714,11 @@ def task_done(_task: asyncio.Task) -> None:
 
             if exc is not None:
                 if task_status_future is None or task_status_future.done():
-                    self._exceptions.append(exc)
-                    self.cancel_scope.cancel()
+                    if not isinstance(exc, CancelledError):
+                        self._exceptions.append(exc)
+
+                    if not self.cancel_scope._parent_cancelled():
+                        self.cancel_scope.cancel()
                 else:
                     task_status_future.set_exception(exc)
             elif task_status_future is not None and not task_status_future.done():
@@ -736,56 +731,62 @@ def task_done(_task: asyncio.Task) -> None:
                 "This task group is not active; no new tasks can be started."
             )
 
-        options = {}
-        name = get_callable_name(func) if name is None else str(name)
-        if _native_task_names:
-            options["name"] = name
-
         kwargs = {}
         if task_status_future:
-            kwargs["task_status"] = _AsyncioTaskStatus(task_status_future)
+            parent_id = id(current_task())
+            kwargs["task_status"] = _AsyncioTaskStatus(
+                task_status_future, id(self.cancel_scope._host_task)
+            )
+        else:
+            parent_id = id(self.cancel_scope._host_task)
 
         coro = func(*args, **kwargs)
-        if not asyncio.iscoroutine(coro):
+        if not iscoroutine(coro):
+            prefix = f"{func.__module__}." if hasattr(func, "__module__") else ""
             raise TypeError(
-                f"Expected an async function, but {func} appears to be synchronous"
+                f"Expected {prefix}{func.__qualname__}() to return a coroutine, but "
+                f"the return value ({coro!r}) is not a coroutine object"
             )
 
-        foreign_coro = not hasattr(coro, "cr_frame") and not hasattr(coro, "gi_frame")
-        if foreign_coro or sys.version_info < (3, 8):
-            coro = self._run_wrapped_task(coro, task_status_future)
-
-        task = create_task(coro, **options)
-        if not foreign_coro and sys.version_info >= (3, 8):
-            task.add_done_callback(task_done)
+        name = get_callable_name(func) if name is None else str(name)
+        task = create_task(coro, name=name)
+        task.add_done_callback(task_done)
 
         # Make the spawned task inherit the task group's cancel scope
         _task_states[task] = TaskState(
-            parent_id=id(current_task()), name=name, cancel_scope=self.cancel_scope
+            parent_id=parent_id, cancel_scope=self.cancel_scope
         )
         self.cancel_scope._tasks.add(task)
+        self._tasks.add(task)
         return task
 
     def start_soon(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[Any]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
     ) -> None:
         self._spawn(func, args, name)
 
     async def start(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
-    ) -> None:
+        self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None
+    ) -> Any:
         future: asyncio.Future = asyncio.Future()
         task = self._spawn(func, args, name, future)
 
-        # If the task raises an exception after sending a start value without a switch point
-        # between, the task group is cancelled and this method never proceeds to process the
-        # completed future. That's why we have to have a shielded cancel scope here.
-        with CancelScope(shield=True):
-            try:
-                return await future
-            except CancelledError:
-                task.cancel()
-                raise
+        # If the task raises an exception after sending a start value without a switch
+        # point between, the task group is cancelled and this method never proceeds to
+        # process the completed future. That's why we have to have a shielded cancel
+        # scope here.
+        try:
+            return await future
+        except CancelledError:
+            # Cancel the task and wait for it to exit before returning
+            task.cancel()
+            with CancelScope(shield=True), suppress(CancelledError):
+                await task
+
+            raise
 
 
 #
@@ -801,50 +802,57 @@ class WorkerThread(Thread):
     def __init__(
         self,
         root_task: asyncio.Task,
-        workers: Set["WorkerThread"],
-        idle_workers: Deque["WorkerThread"],
+        workers: set[WorkerThread],
+        idle_workers: deque[WorkerThread],
     ):
         super().__init__(name="AnyIO worker thread")
         self.root_task = root_task
         self.workers = workers
         self.idle_workers = idle_workers
         self.loop = root_task._loop
-        self.queue: Queue[Union[Tuple[Callable, tuple, asyncio.Future], None]] = Queue(
-            2
-        )
-        self.idle_since = current_time()
+        self.queue: Queue[
+            tuple[Context, Callable, tuple, asyncio.Future, CancelScope] | None
+        ] = Queue(2)
+        self.idle_since = AsyncIOBackend.current_time()
         self.stopping = False
 
     def _report_result(
-        self, future: asyncio.Future, result: Any, exc: Optional[BaseException]
+        self, future: asyncio.Future, result: Any, exc: BaseException | None
     ) -> None:
-        self.idle_since = current_time()
+        self.idle_since = AsyncIOBackend.current_time()
         if not self.stopping:
             self.idle_workers.append(self)
 
         if not future.cancelled():
             if exc is not None:
+                if isinstance(exc, StopIteration):
+                    new_exc = RuntimeError("coroutine raised StopIteration")
+                    new_exc.__cause__ = exc
+                    exc = new_exc
+
                 future.set_exception(exc)
             else:
                 future.set_result(result)
 
     def run(self) -> None:
-        with claim_worker_thread("asyncio"):
-            threadlocals.loop = self.loop
+        with claim_worker_thread(AsyncIOBackend, self.loop):
             while True:
                 item = self.queue.get()
                 if item is None:
                     # Shutdown command received
                     return
 
-                func, args, future = item
+                context, func, args, future, cancel_scope = item
                 if not future.cancelled():
                     result = None
-                    exception: Optional[BaseException] = None
+                    exception: BaseException | None = None
+                    threadlocals.current_cancel_scope = cancel_scope
                     try:
-                        result = func(*args)
+                        result = context.run(func, *args)
                     except BaseException as exc:
                         exception = exc
+                    finally:
+                        del threadlocals.current_cancel_scope
 
                     if not self.loop.is_closed():
                         self.loop.call_soon_threadsafe(
@@ -853,7 +861,7 @@ def run(self) -> None:
 
                 self.queue.task_done()
 
-    def stop(self, f: Optional[asyncio.Task] = None) -> None:
+    def stop(self, f: asyncio.Task | None = None) -> None:
         self.stopping = True
         self.queue.put_nowait(None)
         self.workers.discard(self)
@@ -863,87 +871,14 @@ def stop(self, f: Optional[asyncio.Task] = None) -> None:
             pass
 
 
-_threadpool_idle_workers: RunVar[Deque[WorkerThread]] = RunVar(
+_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar(
     "_threadpool_idle_workers"
 )
-_threadpool_workers: RunVar[Set[WorkerThread]] = RunVar("_threadpool_workers")
-
-
-async def run_sync_in_worker_thread(
-    func: Callable[..., T_Retval],
-    *args: object,
-    cancellable: bool = False,
-    limiter: Optional["CapacityLimiter"] = None,
-) -> T_Retval:
-    await checkpoint()
-
-    # If this is the first run in this event loop thread, set up the necessary variables
-    try:
-        idle_workers = _threadpool_idle_workers.get()
-        workers = _threadpool_workers.get()
-    except LookupError:
-        idle_workers = deque()
-        workers = set()
-        _threadpool_idle_workers.set(idle_workers)
-        _threadpool_workers.set(workers)
-
-    async with (limiter or current_default_thread_limiter()):
-        with CancelScope(shield=not cancellable):
-            future: asyncio.Future = asyncio.Future()
-            root_task = find_root_task()
-            if not idle_workers:
-                worker = WorkerThread(root_task, workers, idle_workers)
-                worker.start()
-                workers.add(worker)
-                root_task.add_done_callback(worker.stop)
-            else:
-                worker = idle_workers.pop()
-
-                # Prune any other workers that have been idle for MAX_IDLE_TIME seconds or longer
-                now = current_time()
-                while idle_workers:
-                    if now - idle_workers[0].idle_since < WorkerThread.MAX_IDLE_TIME:
-                        break
-
-                    expired_worker = idle_workers.popleft()
-                    expired_worker.root_task.remove_done_callback(expired_worker.stop)
-                    expired_worker.stop()
-
-            worker.queue.put_nowait((func, args, future))
-            return await future
-
-
-def run_sync_from_thread(
-    func: Callable[..., T_Retval],
-    *args: object,
-    loop: Optional[asyncio.AbstractEventLoop] = None,
-) -> T_Retval:
-    @wraps(func)
-    def wrapper() -> None:
-        try:
-            f.set_result(func(*args))
-        except BaseException as exc:
-            f.set_exception(exc)
-            if not isinstance(exc, Exception):
-                raise
-
-    f: concurrent.futures.Future[T_Retval] = Future()
-    loop = loop or threadlocals.loop
-    loop.call_soon_threadsafe(wrapper)
-    return f.result()
-
-
-def run_async_from_thread(
-    func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
-) -> T_Retval:
-    f: concurrent.futures.Future[T_Retval] = asyncio.run_coroutine_threadsafe(
-        func(*args), threadlocals.loop
-    )
-    return f.result()
+_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers")
 
 
 class BlockingPortal(abc.BlockingPortal):
-    def __new__(cls) -> "BlockingPortal":
+    def __new__(cls) -> BlockingPortal:
         return object.__new__(cls)
 
     def __init__(self) -> None:
@@ -952,20 +887,16 @@ def __init__(self) -> None:
 
     def _spawn_task_from_thread(
         self,
-        func: Callable,
-        args: tuple,
-        kwargs: Dict[str, Any],
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
         name: object,
-        future: Future,
+        future: Future[T_Retval],
     ) -> None:
-        run_sync_from_thread(
+        AsyncIOBackend.run_sync_from_thread(
             partial(self._task_group.start_soon, name=name),
-            self._call_func,
-            func,
-            args,
-            kwargs,
-            future,
-            loop=self._loop,
+            (self._call_func, func, args, kwargs, future),
+            self._loop,
         )
 
 
@@ -987,6 +918,7 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
 
     async def aclose(self) -> None:
         self._stream.feed_eof()
+        await AsyncIOBackend.checkpoint()
 
 
 @dataclass(eq=False)
@@ -999,24 +931,33 @@ async def send(self, item: bytes) -> None:
 
     async def aclose(self) -> None:
         self._stream.close()
+        await AsyncIOBackend.checkpoint()
 
 
 @dataclass(eq=False)
 class Process(abc.Process):
     _process: asyncio.subprocess.Process
-    _stdin: Optional[StreamWriterWrapper]
-    _stdout: Optional[StreamReaderWrapper]
-    _stderr: Optional[StreamReaderWrapper]
+    _stdin: StreamWriterWrapper | None
+    _stdout: StreamReaderWrapper | None
+    _stderr: StreamReaderWrapper | None
 
     async def aclose(self) -> None:
-        if self._stdin:
-            await self._stdin.aclose()
-        if self._stdout:
-            await self._stdout.aclose()
-        if self._stderr:
-            await self._stderr.aclose()
+        with CancelScope(shield=True):
+            if self._stdin:
+                await self._stdin.aclose()
+            if self._stdout:
+                await self._stdout.aclose()
+            if self._stderr:
+                await self._stderr.aclose()
 
-        await self.wait()
+        try:
+            await self.wait()
+        except BaseException:
+            self.kill()
+            with CancelScope(shield=True):
+                await self.wait()
+
+            raise
 
     async def wait(self) -> int:
         return await self._process.wait()
@@ -1035,85 +976,56 @@ def pid(self) -> int:
         return self._process.pid
 
     @property
-    def returncode(self) -> Optional[int]:
+    def returncode(self) -> int | None:
         return self._process.returncode
 
     @property
-    def stdin(self) -> Optional[abc.ByteSendStream]:
+    def stdin(self) -> abc.ByteSendStream | None:
         return self._stdin
 
     @property
-    def stdout(self) -> Optional[abc.ByteReceiveStream]:
+    def stdout(self) -> abc.ByteReceiveStream | None:
         return self._stdout
 
     @property
-    def stderr(self) -> Optional[abc.ByteReceiveStream]:
+    def stderr(self) -> abc.ByteReceiveStream | None:
         return self._stderr
 
 
-async def open_process(
-    command: Union[str, Sequence[str]],
-    *,
-    shell: bool,
-    stdin: int,
-    stdout: int,
-    stderr: int,
-    cwd: Union[str, bytes, PathLike, None] = None,
-    env: Optional[Mapping[str, str]] = None,
-) -> Process:
-    await checkpoint()
-    if shell:
-        process = await asyncio.create_subprocess_shell(
-            command,
-            stdin=stdin,
-            stdout=stdout,  # type: ignore[arg-type]
-            stderr=stderr,
-            cwd=cwd,
-            env=env,
-        )
-    else:
-        process = await asyncio.create_subprocess_exec(
-            *command, stdin=stdin, stdout=stdout, stderr=stderr, cwd=cwd, env=env
-        )
-
-    stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None
-    stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None
-    stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None
-    return Process(process, stdin_stream, stdout_stream, stderr_stream)
-
-
 def _forcibly_shutdown_process_pool_on_exit(
-    workers: Set[Process], _task: object
+    workers: set[Process], _task: object
 ) -> None:
     """
     Forcibly shuts down worker processes belonging to this event loop."""
-    child_watcher: Optional[asyncio.AbstractChildWatcher]
-    try:
-        child_watcher = asyncio.get_event_loop_policy().get_child_watcher()
-    except NotImplementedError:
-        child_watcher = None
+    child_watcher: asyncio.AbstractChildWatcher | None = None
+    if sys.version_info < (3, 12):
+        try:
+            child_watcher = asyncio.get_event_loop_policy().get_child_watcher()
+        except NotImplementedError:
+            pass
 
     # Close as much as possible (w/o async/await) to avoid warnings
     for process in workers:
         if process.returncode is None:
             continue
 
-        process._stdin._stream._transport.close()  # type: ignore
-        process._stdout._stream._transport.close()  # type: ignore
-        process._stderr._stream._transport.close()  # type: ignore
+        process._stdin._stream._transport.close()  # type: ignore[union-attr]
+        process._stdout._stream._transport.close()  # type: ignore[union-attr]
+        process._stderr._stream._transport.close()  # type: ignore[union-attr]
         process.kill()
         if child_watcher:
             child_watcher.remove_child_handler(process.pid)
 
 
-async def _shutdown_process_pool_on_exit(workers: Set[Process]) -> None:
+async def _shutdown_process_pool_on_exit(workers: set[abc.Process]) -> None:
     """
     Shuts down worker processes belonging to this event loop.
 
-    NOTE: this only works when the event loop was started using asyncio.run() or anyio.run().
+    NOTE: this only works when the event loop was started using asyncio.run() or
+    anyio.run().
 
     """
-    process: Process
+    process: abc.Process
     try:
         await sleep(math.inf)
     except asyncio.CancelledError:
@@ -1125,24 +1037,16 @@ async def _shutdown_process_pool_on_exit(workers: Set[Process]) -> None:
             await process.aclose()
 
 
-def setup_process_pool_exit_at_shutdown(workers: Set[Process]) -> None:
-    kwargs = {"name": "AnyIO process pool shutdown task"} if _native_task_names else {}
-    create_task(_shutdown_process_pool_on_exit(workers), **kwargs)
-    find_root_task().add_done_callback(
-        partial(_forcibly_shutdown_process_pool_on_exit, workers)
-    )
-
-
 #
 # Sockets and networking
 #
 
 
 class StreamProtocol(asyncio.Protocol):
-    read_queue: Deque[bytes]
+    read_queue: deque[bytes]
     read_event: asyncio.Event
     write_event: asyncio.Event
-    exception: Optional[Exception] = None
+    exception: Exception | None = None
 
     def connection_made(self, transport: asyncio.BaseTransport) -> None:
         self.read_queue = deque()
@@ -1151,7 +1055,7 @@ def connection_made(self, transport: asyncio.BaseTransport) -> None:
         self.write_event.set()
         cast(asyncio.Transport, transport).set_write_buffer_limits(0)
 
-    def connection_lost(self, exc: Optional[Exception]) -> None:
+    def connection_lost(self, exc: Exception | None) -> None:
         if exc:
             self.exception = BrokenResourceError()
             self.exception.__cause__ = exc
@@ -1163,7 +1067,7 @@ def data_received(self, data: bytes) -> None:
         self.read_queue.append(data)
         self.read_event.set()
 
-    def eof_received(self) -> Optional[bool]:
+    def eof_received(self) -> bool | None:
         self.read_event.set()
         return True
 
@@ -1175,10 +1079,10 @@ def resume_writing(self) -> None:
 
 
 class DatagramProtocol(asyncio.DatagramProtocol):
-    read_queue: Deque[Tuple[bytes, IPSockAddrType]]
+    read_queue: deque[tuple[bytes, IPSockAddrType]]
     read_event: asyncio.Event
     write_event: asyncio.Event
-    exception: Optional[Exception] = None
+    exception: Exception | None = None
 
     def connection_made(self, transport: asyncio.BaseTransport) -> None:
         self.read_queue = deque(maxlen=100)  # arbitrary value
@@ -1186,7 +1090,7 @@ def connection_made(self, transport: asyncio.BaseTransport) -> None:
         self.write_event = asyncio.Event()
         self.write_event.set()
 
-    def connection_lost(self, exc: Optional[Exception]) -> None:
+    def connection_lost(self, exc: Exception | None) -> None:
         self.read_event.set()
         self.write_event.set()
 
@@ -1219,7 +1123,7 @@ def _raw_socket(self) -> socket.socket:
 
     async def receive(self, max_bytes: int = 65536) -> bytes:
         with self._receive_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
 
             if (
                 not self._protocol.read_event.is_set()
@@ -1235,7 +1139,7 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
                 if self._closed:
                     raise ClosedResourceError from None
                 elif self._protocol.exception:
-                    raise self._protocol.exception
+                    raise self._protocol.exception from None
                 else:
                     raise EndOfStream from None
 
@@ -1244,8 +1148,8 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
                 chunk, leftover = chunk[:max_bytes], chunk[max_bytes:]
                 self._protocol.read_queue.appendleft(leftover)
 
-            # If the read queue is empty, clear the flag so that the next call will block until
-            # data is available
+            # If the read queue is empty, clear the flag so that the next call will
+            # block until data is available
             if not self._protocol.read_queue:
                 self._protocol.read_event.clear()
 
@@ -1253,7 +1157,7 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
 
     async def send(self, item: bytes) -> None:
         with self._send_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
 
             if self._closed:
                 raise ClosedResourceError
@@ -1289,14 +1193,13 @@ async def aclose(self) -> None:
             self._transport.abort()
 
 
-class UNIXSocketStream(abc.SocketStream):
-    _receive_future: Optional[asyncio.Future] = None
-    _send_future: Optional[asyncio.Future] = None
+class _RawSocketMixin:
+    _receive_future: asyncio.Future | None = None
+    _send_future: asyncio.Future | None = None
     _closing = False
 
     def __init__(self, raw_socket: socket.socket):
         self.__raw_socket = raw_socket
-        self._loop = get_running_loop()
         self._receive_guard = ResourceGuard("reading from")
         self._send_guard = ResourceGuard("writing to")
 
@@ -1310,7 +1213,7 @@ def callback(f: object) -> None:
             loop.remove_reader(self.__raw_socket)
 
         f = self._receive_future = asyncio.Future()
-        self._loop.add_reader(self.__raw_socket, f.set_result, None)
+        loop.add_reader(self.__raw_socket, f.set_result, None)
         f.add_done_callback(callback)
         return f
 
@@ -1320,21 +1223,34 @@ def callback(f: object) -> None:
             loop.remove_writer(self.__raw_socket)
 
         f = self._send_future = asyncio.Future()
-        self._loop.add_writer(self.__raw_socket, f.set_result, None)
+        loop.add_writer(self.__raw_socket, f.set_result, None)
         f.add_done_callback(callback)
         return f
 
+    async def aclose(self) -> None:
+        if not self._closing:
+            self._closing = True
+            if self.__raw_socket.fileno() != -1:
+                self.__raw_socket.close()
+
+            if self._receive_future:
+                self._receive_future.set_result(None)
+            if self._send_future:
+                self._send_future.set_result(None)
+
+
+class UNIXSocketStream(_RawSocketMixin, abc.UNIXSocketStream):
     async def send_eof(self) -> None:
         with self._send_guard:
             self._raw_socket.shutdown(socket.SHUT_WR)
 
     async def receive(self, max_bytes: int = 65536) -> bytes:
         loop = get_running_loop()
-        await checkpoint()
+        await AsyncIOBackend.checkpoint()
         with self._receive_guard:
             while True:
                 try:
-                    data = self.__raw_socket.recv(max_bytes)
+                    data = self._raw_socket.recv(max_bytes)
                 except BlockingIOError:
                     await self._wait_until_readable(loop)
                 except OSError as exc:
@@ -1350,12 +1266,12 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
 
     async def send(self, item: bytes) -> None:
         loop = get_running_loop()
-        await checkpoint()
+        await AsyncIOBackend.checkpoint()
         with self._send_guard:
             view = memoryview(item)
             while view:
                 try:
-                    bytes_sent = self.__raw_socket.send(item)
+                    bytes_sent = self._raw_socket.send(view)
                 except BlockingIOError:
                     await self._wait_until_writable(loop)
                 except OSError as exc:
@@ -1366,7 +1282,7 @@ async def send(self, item: bytes) -> None:
                 else:
                     view = view[bytes_sent:]
 
-    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
         if not isinstance(msglen, int) or msglen < 0:
             raise ValueError("msglen must be a non-negative integer")
         if not isinstance(maxfds, int) or maxfds < 1:
@@ -1374,11 +1290,11 @@ async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]
 
         loop = get_running_loop()
         fds = array.array("i")
-        await checkpoint()
+        await AsyncIOBackend.checkpoint()
         with self._receive_guard:
             while True:
                 try:
-                    message, ancdata, flags, addr = self.__raw_socket.recvmsg(
+                    message, ancdata, flags, addr = self._raw_socket.recvmsg(
                         msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
                     )
                 except BlockingIOError:
@@ -1405,16 +1321,14 @@ async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]
 
         return message, list(fds)
 
-    async def send_fds(
-        self, message: bytes, fds: Collection[Union[int, IOBase]]
-    ) -> None:
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
         if not message:
             raise ValueError("message must not be empty")
         if not fds:
             raise ValueError("fds must not be empty")
 
         loop = get_running_loop()
-        filenos: List[int] = []
+        filenos: list[int] = []
         for fd in fds:
             if isinstance(fd, int):
                 filenos.append(fd)
@@ -1422,15 +1336,14 @@ async def send_fds(
                 filenos.append(fd.fileno())
 
         fdarray = array.array("i", filenos)
-        await checkpoint()
+        await AsyncIOBackend.checkpoint()
         with self._send_guard:
             while True:
                 try:
                     # The ignore can be removed after mypy picks up
                     # https://github.com/python/typeshed/pull/5545
-                    self.__raw_socket.sendmsg(
-                        [message],
-                        [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)],  # type: ignore
+                    self._raw_socket.sendmsg(
+                        [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)]
                     )
                     break
                 except BlockingIOError:
@@ -1441,20 +1354,9 @@ async def send_fds(
                     else:
                         raise BrokenResourceError from exc
 
-    async def aclose(self) -> None:
-        if not self._closing:
-            self._closing = True
-            if self.__raw_socket.fileno() != -1:
-                self.__raw_socket.close()
-
-            if self._receive_future:
-                self._receive_future.set_result(None)
-            if self._send_future:
-                self._send_future.set_result(None)
-
 
 class TCPSocketListener(abc.SocketListener):
-    _accept_scope: Optional[CancelScope] = None
+    _accept_scope: CancelScope | None = None
     _closed = False
 
     def __init__(self, raw_socket: socket.socket):
@@ -1471,7 +1373,7 @@ async def accept(self) -> abc.SocketStream:
             raise ClosedResourceError
 
         with self._accept_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
             with CancelScope() as self._accept_scope:
                 try:
                     client_sock, _addr = await self._loop.sock_accept(self._raw_socket)
@@ -1493,9 +1395,7 @@ async def accept(self) -> abc.SocketStream:
         transport, protocol = await self._loop.connect_accepted_socket(
             StreamProtocol, client_sock
         )
-        return SocketStream(
-            cast(asyncio.Transport, transport), cast(StreamProtocol, protocol)
-        )
+        return SocketStream(transport, protocol)
 
     async def aclose(self) -> None:
         if self._closed:
@@ -1523,11 +1423,12 @@ def __init__(self, raw_socket: socket.socket):
         self._closed = False
 
     async def accept(self) -> abc.SocketStream:
-        await checkpoint()
+        await AsyncIOBackend.checkpoint()
         with self._accept_guard:
             while True:
                 try:
                     client_sock, _ = self.__raw_socket.accept()
+                    client_sock.setblocking(False)
                     return UNIXSocketStream(client_sock)
                 except BlockingIOError:
                     f: asyncio.Future = asyncio.Future()
@@ -1570,9 +1471,9 @@ async def aclose(self) -> None:
             self._closed = True
             self._transport.close()
 
-    async def receive(self) -> Tuple[bytes, IPSockAddrType]:
+    async def receive(self) -> tuple[bytes, IPSockAddrType]:
         with self._receive_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
 
             # If the buffer is empty, ask for more data
             if not self._protocol.read_queue and not self._transport.is_closing():
@@ -1589,7 +1490,7 @@ async def receive(self) -> Tuple[bytes, IPSockAddrType]:
 
     async def send(self, item: UDPPacketType) -> None:
         with self._send_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
             await self._protocol.write_event.wait()
             if self._closed:
                 raise ClosedResourceError
@@ -1620,7 +1521,7 @@ async def aclose(self) -> None:
 
     async def receive(self) -> bytes:
         with self._receive_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
 
             # If the buffer is empty, ask for more data
             if not self._protocol.read_queue and not self._transport.is_closing():
@@ -1639,7 +1540,7 @@ async def receive(self) -> bytes:
 
     async def send(self, item: bytes) -> None:
         with self._send_guard:
-            await checkpoint()
+            await AsyncIOBackend.checkpoint()
             await self._protocol.write_event.wait()
             if self._closed:
                 raise ClosedResourceError
@@ -1649,140 +1550,80 @@ async def send(self, item: bytes) -> None:
                 self._transport.sendto(item)
 
 
-async def connect_tcp(
-    host: str, port: int, local_addr: Optional[Tuple[str, int]] = None
-) -> SocketStream:
-    transport, protocol = cast(
-        Tuple[asyncio.Transport, StreamProtocol],
-        await get_running_loop().create_connection(
-            StreamProtocol, host, port, local_addr=local_addr
-        ),
-    )
-    transport.pause_reading()
-    return SocketStream(transport, protocol)
-
-
-async def connect_unix(path: str) -> UNIXSocketStream:
-    await checkpoint()
-    loop = get_running_loop()
-    raw_socket = socket.socket(socket.AF_UNIX)
-    raw_socket.setblocking(False)
-    while True:
-        try:
-            raw_socket.connect(path)
-        except BlockingIOError:
-            f: asyncio.Future = asyncio.Future()
-            loop.add_writer(raw_socket, f.set_result, None)
-            f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
-            await f
-        except BaseException:
-            raw_socket.close()
-            raise
-        else:
-            return UNIXSocketStream(raw_socket)
-
-
-async def create_udp_socket(
-    family: socket.AddressFamily,
-    local_address: Optional[IPSockAddrType],
-    remote_address: Optional[IPSockAddrType],
-    reuse_port: bool,
-) -> Union[UDPSocket, ConnectedUDPSocket]:
-    result = await get_running_loop().create_datagram_endpoint(
-        DatagramProtocol,
-        local_addr=local_address,
-        remote_addr=remote_address,
-        family=family,
-        reuse_port=reuse_port,
-    )
-    transport = cast(asyncio.DatagramTransport, result[0])
-    protocol = cast(DatagramProtocol, result[1])
-    if protocol.exception:
-        transport.close()
-        raise protocol.exception
-
-    if not remote_address:
-        return UDPSocket(transport, protocol)
-    else:
-        return ConnectedUDPSocket(transport, protocol)
-
-
-async def getaddrinfo(
-    host: Union[bytearray, bytes, str],
-    port: Union[str, int, None],
-    *,
-    family: Union[int, AddressFamily] = 0,
-    type: Union[int, SocketKind] = 0,
-    proto: int = 0,
-    flags: int = 0,
-) -> GetAddrInfoReturnType:
-    # https://github.com/python/typeshed/pull/4304
-    result = await get_running_loop().getaddrinfo(
-        host, port, family=family, type=type, proto=proto, flags=flags
-    )  # type: ignore[arg-type]
-    return cast(GetAddrInfoReturnType, result)
-
-
-async def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Tuple[str, str]:
-    return await get_running_loop().getnameinfo(sockaddr, flags)
-
-
-_read_events: RunVar[Dict[Any, asyncio.Event]] = RunVar("read_events")
-_write_events: RunVar[Dict[Any, asyncio.Event]] = RunVar("write_events")
-
-
-async def wait_socket_readable(sock: socket.socket) -> None:
-    await checkpoint()
-    try:
-        read_events = _read_events.get()
-    except LookupError:
-        read_events = {}
-        _read_events.set(read_events)
-
-    if read_events.get(sock):
-        raise BusyResourceError("reading from") from None
+class UNIXDatagramSocket(_RawSocketMixin, abc.UNIXDatagramSocket):
+    async def receive(self) -> UNIXDatagramPacketType:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self._raw_socket.recvfrom(65536)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return data
 
-    loop = get_running_loop()
-    event = read_events[sock] = asyncio.Event()
-    loop.add_reader(sock, event.set)
-    try:
-        await event.wait()
-    finally:
-        if read_events.pop(sock, None) is not None:
-            loop.remove_reader(sock)
-            readable = True
-        else:
-            readable = False
+    async def send(self, item: UNIXDatagramPacketType) -> None:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    self._raw_socket.sendto(*item)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return
 
-    if not readable:
-        raise ClosedResourceError
 
+class ConnectedUNIXDatagramSocket(_RawSocketMixin, abc.ConnectedUNIXDatagramSocket):
+    async def receive(self) -> bytes:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self._raw_socket.recv(65536)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return data
 
-async def wait_socket_writable(sock: socket.socket) -> None:
-    await checkpoint()
-    try:
-        write_events = _write_events.get()
-    except LookupError:
-        write_events = {}
-        _write_events.set(write_events)
+    async def send(self, item: bytes) -> None:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    self._raw_socket.send(item)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return
 
-    if write_events.get(sock):
-        raise BusyResourceError("writing to") from None
 
-    loop = get_running_loop()
-    event = write_events[sock] = asyncio.Event()
-    loop.add_writer(sock.fileno(), event.set)
-    try:
-        await event.wait()
-    finally:
-        if write_events.pop(sock, None) is not None:
-            loop.remove_writer(sock)
-            writable = True
-        else:
-            writable = False
-
-    if not writable:
-        raise ClosedResourceError
+_read_events: RunVar[dict[Any, asyncio.Event]] = RunVar("read_events")
+_write_events: RunVar[dict[Any, asyncio.Event]] = RunVar("write_events")
 
 
 #
@@ -1791,22 +1632,23 @@ async def wait_socket_writable(sock: socket.socket) -> None:
 
 
 class Event(BaseEvent):
-    def __new__(cls) -> "Event":
+    def __new__(cls) -> Event:
         return object.__new__(cls)
 
     def __init__(self) -> None:
         self._event = asyncio.Event()
 
-    def set(self) -> DeprecatedAwaitable:
+    def set(self) -> None:
         self._event.set()
-        return DeprecatedAwaitable(self.set)
 
     def is_set(self) -> bool:
         return self._event.is_set()
 
     async def wait(self) -> None:
-        if await self._event.wait():
-            await checkpoint()
+        if self.is_set():
+            await AsyncIOBackend.checkpoint()
+        else:
+            await self._event.wait()
 
     def statistics(self) -> EventStatistics:
         return EventStatistics(len(self._event._waiters))  # type: ignore[attr-defined]
@@ -1815,12 +1657,12 @@ def statistics(self) -> EventStatistics:
 class CapacityLimiter(BaseCapacityLimiter):
     _total_tokens: float = 0
 
-    def __new__(cls, total_tokens: float) -> "CapacityLimiter":
+    def __new__(cls, total_tokens: float) -> CapacityLimiter:
         return object.__new__(cls)
 
     def __init__(self, total_tokens: float):
-        self._borrowers: Set[Any] = set()
-        self._wait_queue: Dict[Any, asyncio.Event] = OrderedDict()
+        self._borrowers: set[Any] = set()
+        self._wait_queue: OrderedDict[Any, asyncio.Event] = OrderedDict()
         self.total_tokens = total_tokens
 
     async def __aenter__(self) -> None:
@@ -1828,9 +1670,9 @@ async def __aenter__(self) -> None:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.release()
 
@@ -1845,19 +1687,14 @@ def total_tokens(self, value: float) -> None:
         if value < 1:
             raise ValueError("total_tokens must be >= 1")
 
-        old_value = self._total_tokens
+        waiters_to_notify = max(value - self._total_tokens, 0)
         self._total_tokens = value
-        events = []
-        for event in self._wait_queue.values():
-            if value <= old_value:
-                break
-
-            if not event.is_set():
-                events.append(event)
-                old_value += 1
 
-        for event in events:
+        # Notify waiting tasks that they have acquired the limiter
+        while self._wait_queue and waiters_to_notify:
+            event = self._wait_queue.popitem(last=False)[1]
             event.set()
+            waiters_to_notify -= 1
 
     @property
     def borrowed_tokens(self) -> int:
@@ -1867,11 +1704,10 @@ def borrowed_tokens(self) -> int:
     def available_tokens(self) -> float:
         return self._total_tokens - len(self._borrowers)
 
-    def acquire_nowait(self) -> DeprecatedAwaitable:
+    def acquire_nowait(self) -> None:
         self.acquire_on_behalf_of_nowait(current_task())
-        return DeprecatedAwaitable(self.acquire_nowait)
 
-    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
         if borrower in self._borrowers:
             raise RuntimeError(
                 "this borrower is already holding one of this CapacityLimiter's "
@@ -1882,13 +1718,12 @@ def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
             raise WouldBlock
 
         self._borrowers.add(borrower)
-        return DeprecatedAwaitable(self.acquire_on_behalf_of_nowait)
 
     async def acquire(self) -> None:
         return await self.acquire_on_behalf_of(current_task())
 
     async def acquire_on_behalf_of(self, borrower: object) -> None:
-        await checkpoint_if_cancelled()
+        await AsyncIOBackend.checkpoint_if_cancelled()
         try:
             self.acquire_on_behalf_of_nowait(borrower)
         except WouldBlock:
@@ -1902,7 +1737,11 @@ async def acquire_on_behalf_of(self, borrower: object) -> None:
 
             self._borrowers.add(borrower)
         else:
-            await cancel_shielded_checkpoint()
+            try:
+                await AsyncIOBackend.cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
 
     def release(self) -> None:
         self.release_on_behalf_of(current_task())
@@ -1917,7 +1756,7 @@ def release_on_behalf_of(self, borrower: object) -> None:
 
         # Notify the next task in line if this limiter has free capacity now
         if self._wait_queue and len(self._borrowers) < self._total_tokens:
-            event = self._wait_queue.popitem()[1]
+            event = self._wait_queue.popitem(last=False)[1]
             event.set()
 
     def statistics(self) -> CapacityLimiterStatistics:
@@ -1932,34 +1771,25 @@ def statistics(self) -> CapacityLimiterStatistics:
 _default_thread_limiter: RunVar[CapacityLimiter] = RunVar("_default_thread_limiter")
 
 
-def current_default_thread_limiter() -> CapacityLimiter:
-    try:
-        return _default_thread_limiter.get()
-    except LookupError:
-        limiter = CapacityLimiter(40)
-        _default_thread_limiter.set(limiter)
-        return limiter
-
-
 #
 # Operating system signals
 #
 
 
-class _SignalReceiver(DeprecatedAsyncContextManager["_SignalReceiver"]):
-    def __init__(self, signals: Tuple[int, ...]):
+class _SignalReceiver:
+    def __init__(self, signals: tuple[Signals, ...]):
         self._signals = signals
         self._loop = get_running_loop()
-        self._signal_queue: Deque[int] = deque()
+        self._signal_queue: deque[Signals] = deque()
         self._future: asyncio.Future = asyncio.Future()
-        self._handled_signals: Set[int] = set()
+        self._handled_signals: set[Signals] = set()
 
-    def _deliver(self, signum: int) -> None:
+    def _deliver(self, signum: Signals) -> None:
         self._signal_queue.append(signum)
         if not self._future.done():
             self._future.set_result(None)
 
-    def __enter__(self) -> "_SignalReceiver":
+    def __enter__(self) -> _SignalReceiver:
         for sig in set(self._signals):
             self._loop.add_signal_handler(sig, self._deliver, sig)
             self._handled_signals.add(sig)
@@ -1968,19 +1798,19 @@ def __enter__(self) -> "_SignalReceiver":
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         for sig in self._handled_signals:
             self._loop.remove_signal_handler(sig)
         return None
 
-    def __aiter__(self) -> "_SignalReceiver":
+    def __aiter__(self) -> _SignalReceiver:
         return self
 
-    async def __anext__(self) -> int:
-        await checkpoint()
+    async def __anext__(self) -> Signals:
+        await AsyncIOBackend.checkpoint()
         if not self._signal_queue:
             self._future = asyncio.Future()
             await self._future
@@ -1988,10 +1818,6 @@ async def __anext__(self) -> int:
         return self._signal_queue.popleft()
 
 
-def open_signal_receiver(*signals: int) -> _SignalReceiver:
-    return _SignalReceiver(signals)
-
-
 #
 # Testing and debugging
 #
@@ -2000,97 +1826,653 @@ def open_signal_receiver(*signals: int) -> _SignalReceiver:
 def _create_task_info(task: asyncio.Task) -> TaskInfo:
     task_state = _task_states.get(task)
     if task_state is None:
-        name = task.get_name() if _native_task_names else None
         parent_id = None
     else:
-        name = task_state.name
         parent_id = task_state.parent_id
 
-    return TaskInfo(id(task), parent_id, name, get_coro(task))
+    return TaskInfo(id(task), parent_id, task.get_name(), task.get_coro())
 
 
-def get_current_task() -> TaskInfo:
-    return _create_task_info(current_task())  # type: ignore
+class TestRunner(abc.TestRunner):
+    _send_stream: MemoryObjectSendStream[tuple[Awaitable[Any], asyncio.Future[Any]]]
+
+    def __init__(
+        self,
+        *,
+        debug: bool | None = None,
+        use_uvloop: bool = False,
+        loop_factory: Callable[[], AbstractEventLoop] | None = None,
+    ) -> None:
+        if use_uvloop and loop_factory is None:
+            import uvloop
+
+            loop_factory = uvloop.new_event_loop
 
+        self._runner = Runner(debug=debug, loop_factory=loop_factory)
+        self._exceptions: list[BaseException] = []
+        self._runner_task: asyncio.Task | None = None
 
-def get_running_tasks() -> List[TaskInfo]:
-    return [_create_task_info(task) for task in all_tasks() if not task.done()]
+    def __enter__(self) -> TestRunner:
+        self._runner.__enter__()
+        self.get_loop().set_exception_handler(self._exception_handler)
+        return self
 
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._runner.__exit__(exc_type, exc_val, exc_tb)
 
-async def wait_all_tasks_blocked() -> None:
-    await checkpoint()
-    this_task = current_task()
-    while True:
-        for task in all_tasks():
-            if task is this_task:
-                continue
+    def get_loop(self) -> AbstractEventLoop:
+        return self._runner.get_loop()
 
-            if task._fut_waiter is None or task._fut_waiter.done():  # type: ignore[attr-defined]
-                await sleep(0.1)
-                break
+    def _exception_handler(
+        self, loop: asyncio.AbstractEventLoop, context: dict[str, Any]
+    ) -> None:
+        if isinstance(context.get("exception"), Exception):
+            self._exceptions.append(context["exception"])
         else:
-            return
+            loop.default_exception_handler(context)
 
+    def _raise_async_exceptions(self) -> None:
+        # Re-raise any exceptions raised in asynchronous callbacks
+        if self._exceptions:
+            exceptions, self._exceptions = self._exceptions, []
+            if len(exceptions) == 1:
+                raise exceptions[0]
+            elif exceptions:
+                raise BaseExceptionGroup(
+                    "Multiple exceptions occurred in asynchronous callbacks", exceptions
+                )
 
-class TestRunner(abc.TestRunner):
-    def __init__(
+    @staticmethod
+    async def _run_tests_and_fixtures(
+        receive_stream: MemoryObjectReceiveStream[
+            tuple[Awaitable[T_Retval], asyncio.Future[T_Retval]]
+        ],
+    ) -> None:
+        with receive_stream:
+            async for coro, future in receive_stream:
+                try:
+                    retval = await coro
+                except BaseException as exc:
+                    if not future.cancelled():
+                        future.set_exception(exc)
+                else:
+                    if not future.cancelled():
+                        future.set_result(retval)
+
+    async def _call_in_runner_task(
         self,
-        debug: bool = False,
-        use_uvloop: bool = False,
-        policy: Optional[asyncio.AbstractEventLoopPolicy] = None,
-    ):
-        _maybe_set_event_loop_policy(policy, use_uvloop)
-        self._loop = asyncio.new_event_loop()
-        self._loop.set_debug(debug)
-        asyncio.set_event_loop(self._loop)
+        func: Callable[P, Awaitable[T_Retval]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T_Retval:
+        if not self._runner_task:
+            self._send_stream, receive_stream = create_memory_object_stream[
+                Tuple[Awaitable[Any], asyncio.Future]
+            ](1)
+            self._runner_task = self.get_loop().create_task(
+                self._run_tests_and_fixtures(receive_stream)
+            )
 
-    def _cancel_all_tasks(self) -> None:
-        to_cancel = all_tasks(self._loop)
-        if not to_cancel:
+        coro = func(*args, **kwargs)
+        future: asyncio.Future[T_Retval] = self.get_loop().create_future()
+        self._send_stream.send_nowait((coro, future))
+        return await future
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        asyncgen = fixture_func(**kwargs)
+        fixturevalue: T_Retval = self.get_loop().run_until_complete(
+            self._call_in_runner_task(asyncgen.asend, None)
+        )
+        self._raise_async_exceptions()
+
+        yield fixturevalue
+
+        try:
+            self.get_loop().run_until_complete(
+                self._call_in_runner_task(asyncgen.asend, None)
+            )
+        except StopAsyncIteration:
+            self._raise_async_exceptions()
+        else:
+            self.get_loop().run_until_complete(asyncgen.aclose())
+            raise RuntimeError("Async generator fixture did not stop")
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: dict[str, Any],
+    ) -> T_Retval:
+        retval = self.get_loop().run_until_complete(
+            self._call_in_runner_task(fixture_func, **kwargs)
+        )
+        self._raise_async_exceptions()
+        return retval
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        try:
+            self.get_loop().run_until_complete(
+                self._call_in_runner_task(test_func, **kwargs)
+            )
+        except Exception as exc:
+            self._exceptions.append(exc)
+
+        self._raise_async_exceptions()
+
+
+class AsyncIOBackend(AsyncBackend):
+    @classmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        @wraps(func)
+        async def wrapper() -> T_Retval:
+            task = cast(asyncio.Task, current_task())
+            task.set_name(get_callable_name(func))
+            _task_states[task] = TaskState(None, None)
+
+            try:
+                return await func(*args)
+            finally:
+                del _task_states[task]
+
+        debug = options.get("debug", False)
+        loop_factory = options.get("loop_factory", None)
+        if loop_factory is None and options.get("use_uvloop", False):
+            import uvloop
+
+            loop_factory = uvloop.new_event_loop
+
+        with Runner(debug=debug, loop_factory=loop_factory) as runner:
+            return runner.run(wrapper())
+
+    @classmethod
+    def current_token(cls) -> object:
+        return get_running_loop()
+
+    @classmethod
+    def current_time(cls) -> float:
+        return get_running_loop().time()
+
+    @classmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        return CancelledError
+
+    @classmethod
+    async def checkpoint(cls) -> None:
+        await sleep(0)
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        task = current_task()
+        if task is None:
             return
 
-        for task in to_cancel:
-            task.cancel()
+        try:
+            cancel_scope = _task_states[task].cancel_scope
+        except KeyError:
+            return
+
+        while cancel_scope:
+            if cancel_scope.cancel_called:
+                await sleep(0)
+            elif cancel_scope.shield:
+                break
+            else:
+                cancel_scope = cancel_scope._parent_scope
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        with CancelScope(shield=True):
+            await sleep(0)
+
+    @classmethod
+    async def sleep(cls, delay: float) -> None:
+        await sleep(delay)
+
+    @classmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> CancelScope:
+        return CancelScope(deadline=deadline, shield=shield)
 
-        self._loop.run_until_complete(
-            asyncio.gather(*to_cancel, return_exceptions=True)
+    @classmethod
+    def current_effective_deadline(cls) -> float:
+        try:
+            cancel_scope = _task_states[
+                current_task()  # type: ignore[index]
+            ].cancel_scope
+        except KeyError:
+            return math.inf
+
+        deadline = math.inf
+        while cancel_scope:
+            deadline = min(deadline, cancel_scope.deadline)
+            if cancel_scope._cancel_called:
+                deadline = -math.inf
+                break
+            elif cancel_scope.shield:
+                break
+            else:
+                cancel_scope = cancel_scope._parent_scope
+
+        return deadline
+
+    @classmethod
+    def create_task_group(cls) -> abc.TaskGroup:
+        return TaskGroup()
+
+    @classmethod
+    def create_event(cls) -> abc.Event:
+        return Event()
+
+    @classmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> abc.CapacityLimiter:
+        return CapacityLimiter(total_tokens)
+
+    @classmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: abc.CapacityLimiter | None = None,
+    ) -> T_Retval:
+        await cls.checkpoint()
+
+        # If this is the first run in this event loop thread, set up the necessary
+        # variables
+        try:
+            idle_workers = _threadpool_idle_workers.get()
+            workers = _threadpool_workers.get()
+        except LookupError:
+            idle_workers = deque()
+            workers = set()
+            _threadpool_idle_workers.set(idle_workers)
+            _threadpool_workers.set(workers)
+
+        async with limiter or cls.current_default_thread_limiter():
+            with CancelScope(shield=not abandon_on_cancel) as scope:
+                future: asyncio.Future = asyncio.Future()
+                root_task = find_root_task()
+                if not idle_workers:
+                    worker = WorkerThread(root_task, workers, idle_workers)
+                    worker.start()
+                    workers.add(worker)
+                    root_task.add_done_callback(worker.stop)
+                else:
+                    worker = idle_workers.pop()
+
+                    # Prune any other workers that have been idle for MAX_IDLE_TIME
+                    # seconds or longer
+                    now = cls.current_time()
+                    while idle_workers:
+                        if (
+                            now - idle_workers[0].idle_since
+                            < WorkerThread.MAX_IDLE_TIME
+                        ):
+                            break
+
+                        expired_worker = idle_workers.popleft()
+                        expired_worker.root_task.remove_done_callback(
+                            expired_worker.stop
+                        )
+                        expired_worker.stop()
+
+                context = copy_context()
+                context.run(sniffio.current_async_library_cvar.set, None)
+                if abandon_on_cancel or scope._parent_scope is None:
+                    worker_scope = scope
+                else:
+                    worker_scope = scope._parent_scope
+
+                worker.queue.put_nowait((context, func, args, future, worker_scope))
+                return await future
+
+    @classmethod
+    def check_cancelled(cls) -> None:
+        scope: CancelScope | None = threadlocals.current_cancel_scope
+        while scope is not None:
+            if scope.cancel_called:
+                raise CancelledError(f"Cancelled by cancel scope {id(scope):x}")
+
+            if scope.shield:
+                return
+
+            scope = scope._parent_scope
+
+    @classmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        async def task_wrapper(scope: CancelScope) -> T_Retval:
+            __tracebackhide__ = True
+            task = cast(asyncio.Task, current_task())
+            _task_states[task] = TaskState(None, scope)
+            scope._tasks.add(task)
+            try:
+                return await func(*args)
+            except CancelledError as exc:
+                raise concurrent.futures.CancelledError(str(exc)) from None
+            finally:
+                scope._tasks.discard(task)
+
+        loop = cast(AbstractEventLoop, token)
+        context = copy_context()
+        context.run(sniffio.current_async_library_cvar.set, "asyncio")
+        wrapper = task_wrapper(threadlocals.current_cancel_scope)
+        f: concurrent.futures.Future[T_Retval] = context.run(
+            asyncio.run_coroutine_threadsafe, wrapper, loop
         )
+        return f.result()
+
+    @classmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        @wraps(func)
+        def wrapper() -> None:
+            try:
+                sniffio.current_async_library_cvar.set("asyncio")
+                f.set_result(func(*args))
+            except BaseException as exc:
+                f.set_exception(exc)
+                if not isinstance(exc, Exception):
+                    raise
 
-        for task in to_cancel:
-            if task.cancelled():
-                continue
-            if task.exception() is not None:
-                raise cast(BaseException, task.exception())
+        f: concurrent.futures.Future[T_Retval] = Future()
+        loop = cast(AbstractEventLoop, token)
+        loop.call_soon_threadsafe(wrapper)
+        return f.result()
+
+    @classmethod
+    def create_blocking_portal(cls) -> abc.BlockingPortal:
+        return BlockingPortal()
+
+    @classmethod
+    async def open_process(
+        cls,
+        command: str | bytes | Sequence[str | bytes],
+        *,
+        shell: bool,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: str | bytes | PathLike | None = None,
+        env: Mapping[str, str] | None = None,
+        start_new_session: bool = False,
+    ) -> Process:
+        await cls.checkpoint()
+        if shell:
+            process = await asyncio.create_subprocess_shell(
+                cast("str | bytes", command),
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                cwd=cwd,
+                env=env,
+                start_new_session=start_new_session,
+            )
+        else:
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                cwd=cwd,
+                env=env,
+                start_new_session=start_new_session,
+            )
+
+        stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None
+        stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None
+        stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None
+        return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+    @classmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None:
+        create_task(
+            _shutdown_process_pool_on_exit(workers),
+            name="AnyIO process pool shutdown task",
+        )
+        find_root_task().add_done_callback(
+            partial(_forcibly_shutdown_process_pool_on_exit, workers)
+        )
+
+    @classmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> abc.SocketStream:
+        transport, protocol = cast(
+            Tuple[asyncio.Transport, StreamProtocol],
+            await get_running_loop().create_connection(
+                StreamProtocol, host, port, local_addr=local_address
+            ),
+        )
+        transport.pause_reading()
+        return SocketStream(transport, protocol)
 
-    def close(self) -> None:
+    @classmethod
+    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
+        await cls.checkpoint()
+        loop = get_running_loop()
+        raw_socket = socket.socket(socket.AF_UNIX)
+        raw_socket.setblocking(False)
+        while True:
+            try:
+                raw_socket.connect(path)
+            except BlockingIOError:
+                f: asyncio.Future = asyncio.Future()
+                loop.add_writer(raw_socket, f.set_result, None)
+                f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
+                await f
+            except BaseException:
+                raw_socket.close()
+                raise
+            else:
+                return UNIXSocketStream(raw_socket)
+
+    @classmethod
+    def create_tcp_listener(cls, sock: socket.socket) -> SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    def create_unix_listener(cls, sock: socket.socket) -> SocketListener:
+        return UNIXSocketListener(sock)
+
+    @classmethod
+    async def create_udp_socket(
+        cls,
+        family: AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        transport, protocol = await get_running_loop().create_datagram_endpoint(
+            DatagramProtocol,
+            local_addr=local_address,
+            remote_addr=remote_address,
+            family=family,
+            reuse_port=reuse_port,
+        )
+        if protocol.exception:
+            transport.close()
+            raise protocol.exception
+
+        if not remote_address:
+            return UDPSocket(transport, protocol)
+        else:
+            return ConnectedUDPSocket(transport, protocol)
+
+    @classmethod
+    async def create_unix_datagram_socket(  # type: ignore[override]
+        cls, raw_socket: socket.socket, remote_path: str | bytes | None
+    ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket:
+        await cls.checkpoint()
+        loop = get_running_loop()
+
+        if remote_path:
+            while True:
+                try:
+                    raw_socket.connect(remote_path)
+                except BlockingIOError:
+                    f: asyncio.Future = asyncio.Future()
+                    loop.add_writer(raw_socket, f.set_result, None)
+                    f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
+                    await f
+                except BaseException:
+                    raw_socket.close()
+                    raise
+                else:
+                    return ConnectedUNIXDatagramSocket(raw_socket)
+        else:
+            return UNIXDatagramSocket(raw_socket)
+
+    @classmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> list[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int],
+        ]
+    ]:
+        return await get_running_loop().getaddrinfo(
+            host, port, family=family, type=type, proto=proto, flags=flags
+        )
+
+    @classmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        return await get_running_loop().getnameinfo(sockaddr, flags)
+
+    @classmethod
+    async def wait_socket_readable(cls, sock: socket.socket) -> None:
+        await cls.checkpoint()
+        try:
+            read_events = _read_events.get()
+        except LookupError:
+            read_events = {}
+            _read_events.set(read_events)
+
+        if read_events.get(sock):
+            raise BusyResourceError("reading from") from None
+
+        loop = get_running_loop()
+        event = read_events[sock] = asyncio.Event()
+        loop.add_reader(sock, event.set)
         try:
-            self._cancel_all_tasks()
-            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+            await event.wait()
         finally:
-            asyncio.set_event_loop(None)
-            self._loop.close()
+            if read_events.pop(sock, None) is not None:
+                loop.remove_reader(sock)
+                readable = True
+            else:
+                readable = False
 
-    def call(
-        self, func: Callable[..., Awaitable[T_Retval]], *args: object, **kwargs: object
-    ) -> T_Retval:
-        def exception_handler(
-            loop: asyncio.AbstractEventLoop, context: Dict[str, Any]
-        ) -> None:
-            exceptions.append(context["exception"])
+        if not readable:
+            raise ClosedResourceError
 
-        exceptions: List[Exception] = []
-        self._loop.set_exception_handler(exception_handler)
+    @classmethod
+    async def wait_socket_writable(cls, sock: socket.socket) -> None:
+        await cls.checkpoint()
         try:
-            retval: T_Retval = self._loop.run_until_complete(func(*args, **kwargs))
-        except Exception as exc:
-            retval = None  # type: ignore[assignment]
-            exceptions.append(exc)
+            write_events = _write_events.get()
+        except LookupError:
+            write_events = {}
+            _write_events.set(write_events)
+
+        if write_events.get(sock):
+            raise BusyResourceError("writing to") from None
+
+        loop = get_running_loop()
+        event = write_events[sock] = asyncio.Event()
+        loop.add_writer(sock.fileno(), event.set)
+        try:
+            await event.wait()
         finally:
-            self._loop.set_exception_handler(None)
+            if write_events.pop(sock, None) is not None:
+                loop.remove_writer(sock)
+                writable = True
+            else:
+                writable = False
 
-        if len(exceptions) == 1:
-            raise exceptions[0]
-        elif exceptions:
-            raise ExceptionGroup(exceptions)
+        if not writable:
+            raise ClosedResourceError
 
-        return retval
+    @classmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        try:
+            return _default_thread_limiter.get()
+        except LookupError:
+            limiter = CapacityLimiter(40)
+            _default_thread_limiter.set(limiter)
+            return limiter
+
+    @classmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> ContextManager[AsyncIterator[Signals]]:
+        return _SignalReceiver(signals)
+
+    @classmethod
+    def get_current_task(cls) -> TaskInfo:
+        return _create_task_info(current_task())  # type: ignore[arg-type]
+
+    @classmethod
+    def get_running_tasks(cls) -> list[TaskInfo]:
+        return [_create_task_info(task) for task in all_tasks() if not task.done()]
+
+    @classmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        await cls.checkpoint()
+        this_task = current_task()
+        while True:
+            for task in all_tasks():
+                if task is this_task:
+                    continue
+
+                waiter = task._fut_waiter  # type: ignore[attr-defined]
+                if waiter is None or waiter.done():
+                    await sleep(0.1)
+                    break
+            else:
+                return
+
+    @classmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        return TestRunner(**options)
+
+
+backend_class = AsyncIOBackend
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_backends/_trio.py b/addon/globalPlugins/spellcheck/libs/anyio/_backends/_trio.py
index dcdd9d4..1a47192 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_backends/_trio.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_backends/_trio.py
@@ -1,41 +1,50 @@
+from __future__ import annotations
+
 import array
 import math
 import socket
+import sys
+import types
+from collections.abc import AsyncIterator, Iterable
 from concurrent.futures import Future
 from dataclasses import dataclass
 from functools import partial
 from io import IOBase
 from os import PathLike
+from signal import Signals
+from socket import AddressFamily, SocketKind
 from types import TracebackType
 from typing import (
+    IO,
     Any,
+    AsyncGenerator,
     Awaitable,
     Callable,
     Collection,
     ContextManager,
     Coroutine,
-    Deque,
-    Dict,
     Generic,
-    List,
     Mapping,
     NoReturn,
-    Optional,
     Sequence,
-    Set,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
+    cast,
+    overload,
 )
 
 import trio.from_thread
+import trio.lowlevel
 from outcome import Error, Outcome, Value
+from trio.lowlevel import (
+    current_root_task,
+    current_task,
+    wait_readable,
+    wait_writable,
+)
 from trio.socket import SocketType as TrioSocketType
 from trio.to_thread import run_sync
 
 from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
-from .._core._compat import DeprecatedAsyncContextManager, DeprecatedAwaitable, T
 from .._core._eventloop import claim_worker_thread
 from .._core._exceptions import (
     BrokenResourceError,
@@ -43,43 +52,41 @@
     ClosedResourceError,
     EndOfStream,
 )
-from .._core._exceptions import ExceptionGroup as BaseExceptionGroup
 from .._core._sockets import convert_ipv6_sockaddr
+from .._core._streams import create_memory_object_stream
 from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
 from .._core._synchronization import Event as BaseEvent
 from .._core._synchronization import ResourceGuard
 from .._core._tasks import CancelScope as BaseCancelScope
-from ..abc import IPSockAddrType, UDPPacketType
+from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType
+from ..abc._eventloop import AsyncBackend
+from ..streams.memory import MemoryObjectSendStream
 
-try:
-    from trio import lowlevel as trio_lowlevel
-except ImportError:
-    from trio import hazmat as trio_lowlevel
-    from trio.hazmat import wait_readable, wait_writable
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
 else:
-    from trio.lowlevel import wait_readable, wait_writable
+    from typing_extensions import ParamSpec
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import TypeVarTuple, Unpack
 
+T = TypeVar("T")
 T_Retval = TypeVar("T_Retval")
 T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType)
+PosArgsT = TypeVarTuple("PosArgsT")
+P = ParamSpec("P")
 
 
 #
 # Event loop
 #
 
-run = trio.run
-current_token = trio.lowlevel.current_trio_token
 RunVar = trio.lowlevel.RunVar
 
 
-#
-# Miscellaneous
-#
-
-sleep = trio.sleep
-
-
 #
 # Timeouts and cancellation
 #
@@ -87,30 +94,28 @@
 
 class CancelScope(BaseCancelScope):
     def __new__(
-        cls, original: Optional[trio.CancelScope] = None, **kwargs: object
-    ) -> "CancelScope":
+        cls, original: trio.CancelScope | None = None, **kwargs: object
+    ) -> CancelScope:
         return object.__new__(cls)
 
-    def __init__(
-        self, original: Optional[trio.CancelScope] = None, **kwargs: object
-    ) -> None:
+    def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None:
         self.__original = original or trio.CancelScope(**kwargs)
 
-    def __enter__(self) -> "CancelScope":
+    def __enter__(self) -> CancelScope:
         self.__original.__enter__()
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        # https://github.com/python-trio/trio-typing/pull/79
         return self.__original.__exit__(exc_type, exc_val, exc_tb)
 
-    def cancel(self) -> DeprecatedAwaitable:
+    def cancel(self) -> None:
         self.__original.cancel()
-        return DeprecatedAwaitable(self.cancel)
 
     @property
     def deadline(self) -> float:
@@ -124,6 +129,10 @@ def deadline(self, value: float) -> None:
     def cancel_called(self) -> bool:
         return self.__original.cancel_called
 
+    @property
+    def cancelled_caught(self) -> bool:
+        return self.__original.cancelled_caught
+
     @property
     def shield(self) -> bool:
         return self.__original.shield
@@ -133,30 +142,18 @@ def shield(self, value: bool) -> None:
         self.__original.shield = value
 
 
-CancelledError = trio.Cancelled
-checkpoint = trio.lowlevel.checkpoint
-checkpoint_if_cancelled = trio.lowlevel.checkpoint_if_cancelled
-cancel_shielded_checkpoint = trio.lowlevel.cancel_shielded_checkpoint
-current_effective_deadline = trio.current_effective_deadline
-current_time = trio.current_time
-
-
 #
 # Task groups
 #
 
 
-class ExceptionGroup(BaseExceptionGroup, trio.MultiError):
-    pass
-
-
 class TaskGroup(abc.TaskGroup):
     def __init__(self) -> None:
         self._active = False
-        self._nursery_manager = trio.open_nursery()
+        self._nursery_manager = trio.open_nursery(strict_exception_groups=True)
         self.cancel_scope = None  # type: ignore[assignment]
 
-    async def __aenter__(self) -> "TaskGroup":
+    async def __aenter__(self) -> TaskGroup:
         self._active = True
         self._nursery = await self._nursery_manager.__aenter__()
         self.cancel_scope = CancelScope(self._nursery.cancel_scope)
@@ -164,18 +161,28 @@ async def __aenter__(self) -> "TaskGroup":
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         try:
             return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)
-        except trio.MultiError as exc:
-            raise ExceptionGroup(exc.exceptions) from None
+        except BaseExceptionGroup as exc:
+            _, rest = exc.split(trio.Cancelled)
+            if not rest:
+                cancelled_exc = trio.Cancelled._create()
+                raise cancelled_exc from exc
+
+            raise
         finally:
             self._active = False
 
-    def start_soon(self, func: Callable, *args: object, name: object = None) -> None:
+    def start_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[Any]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> None:
         if not self._active:
             raise RuntimeError(
                 "This task group is not active; no new tasks can be started."
@@ -184,8 +191,8 @@ def start_soon(self, func: Callable, *args: object, name: object = None) -> None
         self._nursery.start_soon(func, *args, name=name)
 
     async def start(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
-    ) -> object:
+        self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None
+    ) -> Any:
         if not self._active:
             raise RuntimeError(
                 "This task group is not active; no new tasks can be started."
@@ -199,25 +206,8 @@ async def start(
 #
 
 
-async def run_sync_in_worker_thread(
-    func: Callable[..., T_Retval],
-    *args: object,
-    cancellable: bool = False,
-    limiter: Optional[trio.CapacityLimiter] = None,
-) -> T_Retval:
-    def wrapper() -> T_Retval:
-        with claim_worker_thread("trio"):
-            return func(*args)
-
-    return await run_sync(wrapper, cancellable=cancellable, limiter=limiter)
-
-
-run_async_from_thread = trio.from_thread.run
-run_sync_from_thread = trio.from_thread.run_sync
-
-
 class BlockingPortal(abc.BlockingPortal):
-    def __new__(cls) -> "BlockingPortal":
+    def __new__(cls) -> BlockingPortal:
         return object.__new__(cls)
 
     def __init__(self) -> None:
@@ -226,13 +216,13 @@ def __init__(self) -> None:
 
     def _spawn_task_from_thread(
         self,
-        func: Callable,
-        args: tuple,
-        kwargs: Dict[str, Any],
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
         name: object,
-        future: Future,
+        future: Future[T_Retval],
     ) -> None:
-        return trio.from_thread.run_sync(
+        trio.from_thread.run_sync(
             partial(self._task_group.start_soon, name=name),
             self._call_func,
             func,
@@ -252,7 +242,7 @@ def _spawn_task_from_thread(
 class ReceiveStreamWrapper(abc.ByteReceiveStream):
     _stream: trio.abc.ReceiveStream
 
-    async def receive(self, max_bytes: Optional[int] = None) -> bytes:
+    async def receive(self, max_bytes: int | None = None) -> bytes:
         try:
             data = await self._stream.receive_some(max_bytes)
         except trio.ClosedResourceError as exc:
@@ -288,19 +278,26 @@ async def aclose(self) -> None:
 @dataclass(eq=False)
 class Process(abc.Process):
     _process: trio.Process
-    _stdin: Optional[abc.ByteSendStream]
-    _stdout: Optional[abc.ByteReceiveStream]
-    _stderr: Optional[abc.ByteReceiveStream]
+    _stdin: abc.ByteSendStream | None
+    _stdout: abc.ByteReceiveStream | None
+    _stderr: abc.ByteReceiveStream | None
 
     async def aclose(self) -> None:
-        if self._stdin:
-            await self._stdin.aclose()
-        if self._stdout:
-            await self._stdout.aclose()
-        if self._stderr:
-            await self._stderr.aclose()
+        with CancelScope(shield=True):
+            if self._stdin:
+                await self._stdin.aclose()
+            if self._stdout:
+                await self._stdout.aclose()
+            if self._stderr:
+                await self._stderr.aclose()
 
-        await self.wait()
+        try:
+            await self.wait()
+        except BaseException:
+            self.kill()
+            with CancelScope(shield=True):
+                await self.wait()
+            raise
 
     async def wait(self) -> int:
         return await self._process.wait()
@@ -311,7 +308,7 @@ def terminate(self) -> None:
     def kill(self) -> None:
         self._process.kill()
 
-    def send_signal(self, signal: int) -> None:
+    def send_signal(self, signal: Signals) -> None:
         self._process.send_signal(signal)
 
     @property
@@ -319,61 +316,35 @@ def pid(self) -> int:
         return self._process.pid
 
     @property
-    def returncode(self) -> Optional[int]:
+    def returncode(self) -> int | None:
         return self._process.returncode
 
     @property
-    def stdin(self) -> Optional[abc.ByteSendStream]:
+    def stdin(self) -> abc.ByteSendStream | None:
         return self._stdin
 
     @property
-    def stdout(self) -> Optional[abc.ByteReceiveStream]:
+    def stdout(self) -> abc.ByteReceiveStream | None:
         return self._stdout
 
     @property
-    def stderr(self) -> Optional[abc.ByteReceiveStream]:
+    def stderr(self) -> abc.ByteReceiveStream | None:
         return self._stderr
 
 
-async def open_process(
-    command: Union[str, Sequence[str]],
-    *,
-    shell: bool,
-    stdin: int,
-    stdout: int,
-    stderr: int,
-    cwd: Union[str, bytes, PathLike, None] = None,
-    env: Optional[Mapping[str, str]] = None,
-) -> Process:
-    process = await trio.open_process(
-        command,
-        stdin=stdin,
-        stdout=stdout,
-        stderr=stderr,
-        shell=shell,
-        cwd=cwd,
-        env=env,
-    )
-    stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
-    stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
-    stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
-    return Process(process, stdin_stream, stdout_stream, stderr_stream)
-
-
 class _ProcessPoolShutdownInstrument(trio.abc.Instrument):
     def after_run(self) -> None:
         super().after_run()
 
 
-current_default_worker_process_limiter = trio.lowlevel.RunVar(
+current_default_worker_process_limiter: trio.lowlevel.RunVar = RunVar(
     "current_default_worker_process_limiter"
 )
 
 
-async def _shutdown_process_pool(workers: Set[Process]) -> None:
-    process: Process
+async def _shutdown_process_pool(workers: set[abc.Process]) -> None:
     try:
-        await sleep(math.inf)
+        await trio.sleep(math.inf)
     except trio.Cancelled:
         for process in workers:
             if process.returncode is None:
@@ -384,10 +355,6 @@ async def _shutdown_process_pool(workers: Set[Process]) -> None:
                 await process.aclose()
 
 
-def setup_process_pool_exit_at_shutdown(workers: Set[Process]) -> None:
-    trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
-
-
 #
 # Sockets and networking
 #
@@ -406,14 +373,14 @@ def _check_closed(self) -> None:
 
     @property
     def _raw_socket(self) -> socket.socket:
-        return self._trio_socket._sock
+        return self._trio_socket._sock  # type: ignore[attr-defined]
 
     async def aclose(self) -> None:
         if self._trio_socket.fileno() >= 0:
             self._closed = True
             self._trio_socket.close()
 
-    def _convert_socket_error(self, exc: BaseException) -> "NoReturn":
+    def _convert_socket_error(self, exc: BaseException) -> NoReturn:
         if isinstance(exc, trio.ClosedResourceError):
             raise ClosedResourceError from exc
         elif self._trio_socket.fileno() < 0 and self._closed:
@@ -458,14 +425,14 @@ async def send_eof(self) -> None:
 
 
 class UNIXSocketStream(SocketStream, abc.UNIXSocketStream):
-    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
         if not isinstance(msglen, int) or msglen < 0:
             raise ValueError("msglen must be a non-negative integer")
         if not isinstance(maxfds, int) or maxfds < 1:
             raise ValueError("maxfds must be a positive integer")
 
         fds = array.array("i")
-        await checkpoint()
+        await trio.lowlevel.checkpoint()
         with self._receive_guard:
             while True:
                 try:
@@ -483,7 +450,7 @@ async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]
         for cmsg_level, cmsg_type, cmsg_data in ancdata:
             if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
                 raise RuntimeError(
-                    f"Received unexpected ancillary data; message = {message}, "
+                    f"Received unexpected ancillary data; message = {message!r}, "
                     f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
                 )
 
@@ -491,15 +458,13 @@ async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]
 
         return message, list(fds)
 
-    async def send_fds(
-        self, message: bytes, fds: Collection[Union[int, IOBase]]
-    ) -> None:
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
         if not message:
             raise ValueError("message must not be empty")
         if not fds:
             raise ValueError("fds must not be empty")
 
-        filenos: List[int] = []
+        filenos: list[int] = []
         for fd in fds:
             if isinstance(fd, int):
                 filenos.append(fd)
@@ -507,12 +472,19 @@ async def send_fds(
                 filenos.append(fd.fileno())
 
         fdarray = array.array("i", filenos)
-        await checkpoint()
+        await trio.lowlevel.checkpoint()
         with self._send_guard:
             while True:
                 try:
                     await self._trio_socket.sendmsg(
-                        [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)]
+                        [message],
+                        [
+                            (
+                                socket.SOL_SOCKET,
+                                socket.SCM_RIGHTS,
+                                fdarray,
+                            )
+                        ],
                     )
                     break
                 except BaseException as exc:
@@ -556,7 +528,7 @@ def __init__(self, trio_socket: TrioSocketType) -> None:
         self._receive_guard = ResourceGuard("reading from")
         self._send_guard = ResourceGuard("writing to")
 
-    async def receive(self) -> Tuple[bytes, IPSockAddrType]:
+    async def receive(self) -> tuple[bytes, IPSockAddrType]:
         with self._receive_guard:
             try:
                 data, addr = await self._trio_socket.recvfrom(65536)
@@ -593,76 +565,49 @@ async def send(self, item: bytes) -> None:
                 self._convert_socket_error(exc)
 
 
-async def connect_tcp(
-    host: str, port: int, local_address: Optional[IPSockAddrType] = None
-) -> SocketStream:
-    family = socket.AF_INET6 if ":" in host else socket.AF_INET
-    trio_socket = trio.socket.socket(family)
-    trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-    if local_address:
-        await trio_socket.bind(local_address)
-
-    try:
-        await trio_socket.connect((host, port))
-    except BaseException:
-        trio_socket.close()
-        raise
-
-    return SocketStream(trio_socket)
-
-
-async def connect_unix(path: str) -> UNIXSocketStream:
-    trio_socket = trio.socket.socket(socket.AF_UNIX)
-    try:
-        await trio_socket.connect(path)
-    except BaseException:
-        trio_socket.close()
-        raise
-
-    return UNIXSocketStream(trio_socket)
-
-
-async def create_udp_socket(
-    family: socket.AddressFamily,
-    local_address: Optional[IPSockAddrType],
-    remote_address: Optional[IPSockAddrType],
-    reuse_port: bool,
-) -> Union[UDPSocket, ConnectedUDPSocket]:
-    trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
-
-    if reuse_port:
-        trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-
-    if local_address:
-        await trio_socket.bind(local_address)
-
-    if remote_address:
-        await trio_socket.connect(remote_address)
-        return ConnectedUDPSocket(trio_socket)
-    else:
-        return UDPSocket(trio_socket)
+class UNIXDatagramSocket(_TrioSocketMixin[str], abc.UNIXDatagramSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
 
+    async def receive(self) -> UNIXDatagramPacketType:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, addr
+            except BaseException as exc:
+                self._convert_socket_error(exc)
 
-getaddrinfo = trio.socket.getaddrinfo
-getnameinfo = trio.socket.getnameinfo
+    async def send(self, item: UNIXDatagramPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
 
 
-async def wait_socket_readable(sock: socket.socket) -> None:
-    try:
-        await wait_readable(sock)
-    except trio.ClosedResourceError as exc:
-        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
-    except trio.BusyResourceError:
-        raise BusyResourceError("reading from") from None
+class ConnectedUNIXDatagramSocket(
+    _TrioSocketMixin[str], abc.ConnectedUNIXDatagramSocket
+):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
 
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
 
-async def wait_socket_writable(sock: socket.socket) -> None:
-    try:
-        await wait_writable(sock)
-    except trio.ClosedResourceError as exc:
-        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
-    except trio.BusyResourceError:
-        raise BusyResourceError("writing to") from None
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
 
 
 #
@@ -671,7 +616,7 @@ async def wait_socket_writable(sock: socket.socket) -> None:
 
 
 class Event(BaseEvent):
-    def __new__(cls) -> "Event":
+    def __new__(cls) -> Event:
         return object.__new__(cls)
 
     def __init__(self) -> None:
@@ -684,32 +629,44 @@ async def wait(self) -> None:
         return await self.__original.wait()
 
     def statistics(self) -> EventStatistics:
-        return self.__original.statistics()
+        orig_statistics = self.__original.statistics()
+        return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting)
 
-    def set(self) -> DeprecatedAwaitable:
+    def set(self) -> None:
         self.__original.set()
-        return DeprecatedAwaitable(self.set)
 
 
 class CapacityLimiter(BaseCapacityLimiter):
-    def __new__(cls, *args: object, **kwargs: object) -> "CapacityLimiter":
+    def __new__(
+        cls,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
+    ) -> CapacityLimiter:
         return object.__new__(cls)
 
     def __init__(
-        self, *args: object, original: Optional[trio.CapacityLimiter] = None
+        self,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
     ) -> None:
-        self.__original = original or trio.CapacityLimiter(*args)
+        if original is not None:
+            self.__original = original
+        else:
+            assert total_tokens is not None
+            self.__original = trio.CapacityLimiter(total_tokens)
 
     async def __aenter__(self) -> None:
         return await self.__original.__aenter__()
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        return await self.__original.__aexit__(exc_type, exc_val, exc_tb)
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.__original.__aexit__(exc_type, exc_val, exc_tb)
 
     @property
     def total_tokens(self) -> float:
@@ -727,13 +684,11 @@ def borrowed_tokens(self) -> int:
     def available_tokens(self) -> float:
         return self.__original.available_tokens
 
-    def acquire_nowait(self) -> DeprecatedAwaitable:
+    def acquire_nowait(self) -> None:
         self.__original.acquire_nowait()
-        return DeprecatedAwaitable(self.acquire_nowait)
 
-    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
         self.__original.acquire_on_behalf_of_nowait(borrower)
-        return DeprecatedAwaitable(self.acquire_on_behalf_of_nowait)
 
     async def acquire(self) -> None:
         await self.__original.acquire()
@@ -748,21 +703,16 @@ def release_on_behalf_of(self, borrower: object) -> None:
         return self.__original.release_on_behalf_of(borrower)
 
     def statistics(self) -> CapacityLimiterStatistics:
-        return self.__original.statistics()
-
-
-_capacity_limiter_wrapper = RunVar("_capacity_limiter_wrapper")
+        orig = self.__original.statistics()
+        return CapacityLimiterStatistics(
+            borrowed_tokens=orig.borrowed_tokens,
+            total_tokens=orig.total_tokens,
+            borrowers=tuple(orig.borrowers),
+            tasks_waiting=orig.tasks_waiting,
+        )
 
 
-def current_default_thread_limiter() -> CapacityLimiter:
-    try:
-        return _capacity_limiter_wrapper.get()
-    except LookupError:
-        limiter = CapacityLimiter(
-            original=trio.to_thread.current_default_thread_limiter()
-        )
-        _capacity_limiter_wrapper.set(limiter)
-        return limiter
+_capacity_limiter_wrapper: trio.lowlevel.RunVar = RunVar("_capacity_limiter_wrapper")
 
 
 #
@@ -770,25 +720,31 @@ def current_default_thread_limiter() -> CapacityLimiter:
 #
 
 
-class _SignalReceiver(DeprecatedAsyncContextManager[T]):
-    def __init__(self, cm: ContextManager[T]):
-        self._cm = cm
+class _SignalReceiver:
+    _iterator: AsyncIterator[int]
 
-    def __enter__(self) -> T:
-        return self._cm.__enter__()
+    def __init__(self, signals: tuple[Signals, ...]):
+        self._signals = signals
+
+    def __enter__(self) -> _SignalReceiver:
+        self._cm = trio.open_signal_receiver(*self._signals)
+        self._iterator = self._cm.__enter__()
+        return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         return self._cm.__exit__(exc_type, exc_val, exc_tb)
 
+    def __aiter__(self) -> _SignalReceiver:
+        return self
 
-def open_signal_receiver(*signals: int) -> _SignalReceiver:
-    cm = trio.open_signal_receiver(*signals)
-    return _SignalReceiver(cm)
+    async def __anext__(self) -> Signals:
+        signum = await self._iterator.__anext__()
+        return Signals(signum)
 
 
 #
@@ -796,91 +752,418 @@ def open_signal_receiver(*signals: int) -> _SignalReceiver:
 #
 
 
-def get_current_task() -> TaskInfo:
-    task = trio_lowlevel.current_task()
+class TestRunner(abc.TestRunner):
+    def __init__(self, **options: Any) -> None:
+        from queue import Queue
 
-    parent_id = None
-    if task.parent_nursery and task.parent_nursery.parent_task:
-        parent_id = id(task.parent_nursery.parent_task)
+        self._call_queue: Queue[Callable[[], object]] = Queue()
+        self._send_stream: MemoryObjectSendStream | None = None
+        self._options = options
 
-    return TaskInfo(id(task), parent_id, task.name, task.coro)
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
+        if self._send_stream:
+            self._send_stream.close()
+            while self._send_stream is not None:
+                self._call_queue.get()()
 
+    async def _run_tests_and_fixtures(self) -> None:
+        self._send_stream, receive_stream = create_memory_object_stream(1)
+        with receive_stream:
+            async for coro, outcome_holder in receive_stream:
+                try:
+                    retval = await coro
+                except BaseException as exc:
+                    outcome_holder.append(Error(exc))
+                else:
+                    outcome_holder.append(Value(retval))
 
-def get_running_tasks() -> List[TaskInfo]:
-    root_task = trio_lowlevel.current_root_task()
-    task_infos = [TaskInfo(id(root_task), None, root_task.name, root_task.coro)]
-    nurseries = root_task.child_nurseries
-    while nurseries:
-        new_nurseries: List[trio.Nursery] = []
-        for nursery in nurseries:
-            for task in nursery.child_tasks:
-                task_infos.append(
-                    TaskInfo(id(task), id(nursery.parent_task), task.name, task.coro)
-                )
-                new_nurseries.extend(task.child_nurseries)
+    def _main_task_finished(self, outcome: object) -> None:
+        self._send_stream = None
 
-        nurseries = new_nurseries
+    def _call_in_runner_task(
+        self,
+        func: Callable[P, Awaitable[T_Retval]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T_Retval:
+        if self._send_stream is None:
+            trio.lowlevel.start_guest_run(
+                self._run_tests_and_fixtures,
+                run_sync_soon_threadsafe=self._call_queue.put,
+                done_callback=self._main_task_finished,
+                **self._options,
+            )
+            while self._send_stream is None:
+                self._call_queue.get()()
 
-    return task_infos
+        outcome_holder: list[Outcome] = []
+        self._send_stream.send_nowait((func(*args, **kwargs), outcome_holder))
+        while not outcome_holder:
+            self._call_queue.get()()
 
+        return outcome_holder[0].unwrap()
 
-def wait_all_tasks_blocked() -> Awaitable[None]:
-    import trio.testing
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        asyncgen = fixture_func(**kwargs)
+        fixturevalue: T_Retval = self._call_in_runner_task(asyncgen.asend, None)
 
-    return trio.testing.wait_all_tasks_blocked()
+        yield fixturevalue
 
+        try:
+            self._call_in_runner_task(asyncgen.asend, None)
+        except StopAsyncIteration:
+            pass
+        else:
+            self._call_in_runner_task(asyncgen.aclose)
+            raise RuntimeError("Async generator fixture did not stop")
 
-class TestRunner(abc.TestRunner):
-    def __init__(self, **options: object) -> None:
-        from collections import deque
-        from queue import Queue
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: dict[str, Any],
+    ) -> T_Retval:
+        return self._call_in_runner_task(fixture_func, **kwargs)
 
-        self._call_queue: "Queue[Callable[..., object]]" = Queue()
-        self._result_queue: Deque[Outcome] = deque()
-        self._stop_event: Optional[trio.Event] = None
-        self._nursery: Optional[trio.Nursery] = None
-        self._options = options
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        self._call_in_runner_task(test_func, **kwargs)
 
-    async def _trio_main(self) -> None:
-        self._stop_event = trio.Event()
-        async with trio.open_nursery() as self._nursery:
-            await self._stop_event.wait()
 
-    async def _call_func(
-        self, func: Callable[..., Awaitable[object]], args: tuple, kwargs: dict
-    ) -> None:
+class TrioBackend(AsyncBackend):
+    @classmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        return trio.run(func, *args)
+
+    @classmethod
+    def current_token(cls) -> object:
+        return trio.lowlevel.current_trio_token()
+
+    @classmethod
+    def current_time(cls) -> float:
+        return trio.current_time()
+
+    @classmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        return trio.Cancelled
+
+    @classmethod
+    async def checkpoint(cls) -> None:
+        await trio.lowlevel.checkpoint()
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        await trio.lowlevel.checkpoint_if_cancelled()
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        await trio.lowlevel.cancel_shielded_checkpoint()
+
+    @classmethod
+    async def sleep(cls, delay: float) -> None:
+        await trio.sleep(delay)
+
+    @classmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> abc.CancelScope:
+        return CancelScope(deadline=deadline, shield=shield)
+
+    @classmethod
+    def current_effective_deadline(cls) -> float:
+        return trio.current_effective_deadline()
+
+    @classmethod
+    def create_task_group(cls) -> abc.TaskGroup:
+        return TaskGroup()
+
+    @classmethod
+    def create_event(cls) -> abc.Event:
+        return Event()
+
+    @classmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
+        return CapacityLimiter(total_tokens)
+
+    @classmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: abc.CapacityLimiter | None = None,
+    ) -> T_Retval:
+        def wrapper() -> T_Retval:
+            with claim_worker_thread(TrioBackend, token):
+                return func(*args)
+
+        token = TrioBackend.current_token()
+        return await run_sync(
+            wrapper,
+            abandon_on_cancel=abandon_on_cancel,
+            limiter=cast(trio.CapacityLimiter, limiter),
+        )
+
+    @classmethod
+    def check_cancelled(cls) -> None:
+        trio.from_thread.check_cancelled()
+
+    @classmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        return trio.from_thread.run(func, *args)
+
+    @classmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        return trio.from_thread.run_sync(func, *args)
+
+    @classmethod
+    def create_blocking_portal(cls) -> abc.BlockingPortal:
+        return BlockingPortal()
+
+    @classmethod
+    async def open_process(
+        cls,
+        command: str | bytes | Sequence[str | bytes],
+        *,
+        shell: bool,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: str | bytes | PathLike | None = None,
+        env: Mapping[str, str] | None = None,
+        start_new_session: bool = False,
+    ) -> Process:
+        process = await trio.lowlevel.open_process(  # type: ignore[misc]
+            command,  # type: ignore[arg-type]
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            shell=shell,
+            cwd=cwd,
+            env=env,
+            start_new_session=start_new_session,
+        )
+        stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
+        stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
+        stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
+        return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+    @classmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None:
+        trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
+
+    @classmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> SocketStream:
+        family = socket.AF_INET6 if ":" in host else socket.AF_INET
+        trio_socket = trio.socket.socket(family)
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if local_address:
+            await trio_socket.bind(local_address)
+
         try:
-            retval = await func(*args, **kwargs)
-        except BaseException as exc:
-            self._result_queue.append(Error(exc))
-        else:
-            self._result_queue.append(Value(retval))
+            await trio_socket.connect((host, port))
+        except BaseException:
+            trio_socket.close()
+            raise
 
-    def _main_task_finished(self, outcome: object) -> None:
-        self._nursery = None
+        return SocketStream(trio_socket)
 
-    def close(self) -> None:
-        if self._stop_event:
-            self._stop_event.set()
-            while self._nursery is not None:
-                self._call_queue.get()()
+    @classmethod
+    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
+        trio_socket = trio.socket.socket(socket.AF_UNIX)
+        try:
+            await trio_socket.connect(path)
+        except BaseException:
+            trio_socket.close()
+            raise
 
-    def call(
-        self, func: Callable[..., Awaitable[T_Retval]], *args: object, **kwargs: object
-    ) -> T_Retval:
-        if self._nursery is None:
-            trio.lowlevel.start_guest_run(
-                self._trio_main,
-                run_sync_soon_threadsafe=self._call_queue.put,
-                done_callback=self._main_task_finished,
-                **self._options,
+        return UNIXSocketStream(trio_socket)
+
+    @classmethod
+    def create_tcp_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    def create_unix_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return UNIXSocketListener(sock)
+
+    @classmethod
+    async def create_udp_socket(
+        cls,
+        family: socket.AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
+
+        if reuse_port:
+            trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+        if local_address:
+            await trio_socket.bind(local_address)
+
+        if remote_address:
+            await trio_socket.connect(remote_address)
+            return ConnectedUDPSocket(trio_socket)
+        else:
+            return UDPSocket(trio_socket)
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: None
+    ) -> abc.UNIXDatagramSocket:
+        ...
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes
+    ) -> abc.ConnectedUNIXDatagramSocket:
+        ...
+
+    @classmethod
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes | None
+    ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket:
+        trio_socket = trio.socket.from_stdlib_socket(raw_socket)
+
+        if remote_path:
+            await trio_socket.connect(remote_path)
+            return ConnectedUNIXDatagramSocket(trio_socket)
+        else:
+            return UNIXDatagramSocket(trio_socket)
+
+    @classmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> list[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int],
+        ]
+    ]:
+        return await trio.socket.getaddrinfo(host, port, family, type, proto, flags)
+
+    @classmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        return await trio.socket.getnameinfo(sockaddr, flags)
+
+    @classmethod
+    async def wait_socket_readable(cls, sock: socket.socket) -> None:
+        try:
+            await wait_readable(sock)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("reading from") from None
+
+    @classmethod
+    async def wait_socket_writable(cls, sock: socket.socket) -> None:
+        try:
+            await wait_writable(sock)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("writing to") from None
+
+    @classmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        try:
+            return _capacity_limiter_wrapper.get()
+        except LookupError:
+            limiter = CapacityLimiter(
+                original=trio.to_thread.current_default_thread_limiter()
             )
-            while self._nursery is None:
-                self._call_queue.get()()
+            _capacity_limiter_wrapper.set(limiter)
+            return limiter
+
+    @classmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> ContextManager[AsyncIterator[Signals]]:
+        return _SignalReceiver(signals)
+
+    @classmethod
+    def get_current_task(cls) -> TaskInfo:
+        task = current_task()
+
+        parent_id = None
+        if task.parent_nursery and task.parent_nursery.parent_task:
+            parent_id = id(task.parent_nursery.parent_task)
+
+        return TaskInfo(id(task), parent_id, task.name, task.coro)
+
+    @classmethod
+    def get_running_tasks(cls) -> list[TaskInfo]:
+        root_task = current_root_task()
+        assert root_task
+        task_infos = [TaskInfo(id(root_task), None, root_task.name, root_task.coro)]
+        nurseries = root_task.child_nurseries
+        while nurseries:
+            new_nurseries: list[trio.Nursery] = []
+            for nursery in nurseries:
+                for task in nursery.child_tasks:
+                    task_infos.append(
+                        TaskInfo(
+                            id(task), id(nursery.parent_task), task.name, task.coro
+                        )
+                    )
+                    new_nurseries.extend(task.child_nurseries)
+
+            nurseries = new_nurseries
+
+        return task_infos
+
+    @classmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        from trio.testing import wait_all_tasks_blocked
+
+        await wait_all_tasks_blocked()
+
+    @classmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        return TestRunner(**options)
 
-        self._nursery.start_soon(self._call_func, func, args, kwargs)
-        while not self._result_queue:
-            self._call_queue.get()()
 
-        outcome = self._result_queue.pop()
-        return outcome.unwrap()
+backend_class = TrioBackend
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_compat.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_compat.py
deleted file mode 100644
index 94c133a..0000000
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_compat.py
+++ /dev/null
@@ -1,215 +0,0 @@
-from abc import ABCMeta, abstractmethod
-from contextlib import AbstractContextManager
-from types import TracebackType
-from typing import (
-    TYPE_CHECKING,
-    AsyncContextManager,
-    Callable,
-    ContextManager,
-    Generator,
-    Generic,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-from warnings import warn
-
-if TYPE_CHECKING:
-    from ._testing import TaskInfo
-else:
-    TaskInfo = object
-
-T = TypeVar("T")
-AnyDeprecatedAwaitable = Union[
-    "DeprecatedAwaitable",
-    "DeprecatedAwaitableFloat",
-    "DeprecatedAwaitableList",
-    TaskInfo,
-]
-
-
-@overload
-async def maybe_async(__obj: TaskInfo) -> TaskInfo:
-    ...
-
-
-@overload
-async def maybe_async(__obj: "DeprecatedAwaitableFloat") -> float:
-    ...
-
-
-@overload
-async def maybe_async(__obj: "DeprecatedAwaitableList[T]") -> List[T]:
-    ...
-
-
-@overload
-async def maybe_async(__obj: "DeprecatedAwaitable") -> None:
-    ...
-
-
-async def maybe_async(
-    __obj: AnyDeprecatedAwaitable,
-) -> Union[TaskInfo, float, list, None]:
-    """
-    Await on the given object if necessary.
-
-    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
-    methods were converted from coroutine functions into regular functions.
-
-    Do **not** try to use this for any other purpose!
-
-    :return: the result of awaiting on the object if coroutine, or the object itself otherwise
-
-    .. versionadded:: 2.2
-
-    """
-    return __obj._unwrap()
-
-
-class _ContextManagerWrapper:
-    def __init__(self, cm: ContextManager[T]):
-        self._cm = cm
-
-    async def __aenter__(self) -> T:
-        return self._cm.__enter__()
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        return self._cm.__exit__(exc_type, exc_val, exc_tb)
-
-
-def maybe_async_cm(
-    cm: Union[ContextManager[T], AsyncContextManager[T]]
-) -> AsyncContextManager[T]:
-    """
-    Wrap a regular context manager as an async one if necessary.
-
-    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
-    methods were changed to return regular context managers instead of async ones.
-
-    :param cm: a regular or async context manager
-    :return: an async context manager
-
-    .. versionadded:: 2.2
-
-    """
-    if not isinstance(cm, AbstractContextManager):
-        raise TypeError("Given object is not an context manager")
-
-    return _ContextManagerWrapper(cm)
-
-
-def _warn_deprecation(awaitable: AnyDeprecatedAwaitable, stacklevel: int = 1) -> None:
-    warn(
-        f'Awaiting on {awaitable._name}() is deprecated. Use "await '
-        f"anyio.maybe_async({awaitable._name}(...)) if you have to support both AnyIO 2.x "
-        f'and 3.x, or just remove the "await" if you are completely migrating to AnyIO 3+.',
-        DeprecationWarning,
-        stacklevel=stacklevel + 1,
-    )
-
-
-class DeprecatedAwaitable:
-    def __init__(self, func: Callable[..., "DeprecatedAwaitable"]):
-        self._name = f"{func.__module__}.{func.__qualname__}"
-
-    def __await__(self) -> Generator[None, None, None]:
-        _warn_deprecation(self)
-        if False:
-            yield
-
-    def __reduce__(self) -> Tuple[Type[None], Tuple]:
-        return type(None), ()
-
-    def _unwrap(self) -> None:
-        return None
-
-
-class DeprecatedAwaitableFloat(float):
-    def __new__(
-        cls, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]
-    ) -> "DeprecatedAwaitableFloat":
-        return super().__new__(cls, x)
-
-    def __init__(self, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]):
-        self._name = f"{func.__module__}.{func.__qualname__}"
-
-    def __await__(self) -> Generator[None, None, float]:
-        _warn_deprecation(self)
-        if False:
-            yield
-
-        return float(self)
-
-    def __reduce__(self) -> Tuple[Type[float], Tuple[float]]:
-        return float, (float(self),)
-
-    def _unwrap(self) -> float:
-        return float(self)
-
-
-class DeprecatedAwaitableList(List[T]):
-    def __init__(
-        self,
-        iterable: Iterable[T] = (),
-        *,
-        func: Callable[..., "DeprecatedAwaitableList"],
-    ):
-        super().__init__(iterable)
-        self._name = f"{func.__module__}.{func.__qualname__}"
-
-    def __await__(self) -> Generator[None, None, List[T]]:
-        _warn_deprecation(self)
-        if False:
-            yield
-
-        return list(self)
-
-    def __reduce__(self) -> Tuple[Type[list], Tuple[List[T]]]:
-        return list, (list(self),)
-
-    def _unwrap(self) -> List[T]:
-        return list(self)
-
-
-class DeprecatedAsyncContextManager(Generic[T], metaclass=ABCMeta):
-    @abstractmethod
-    def __enter__(self) -> T:
-        pass
-
-    @abstractmethod
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        pass
-
-    async def __aenter__(self) -> T:
-        warn(
-            f"Using {self.__class__.__name__} as an async context manager has been deprecated. "
-            f'Use "async with anyio.maybe_async_cm(yourcontextmanager) as foo:" if you have to '
-            f'support both AnyIO 2.x and 3.x, or just remove the "async" from "async with" if '
-            f"you are completely migrating to AnyIO 3+.",
-            DeprecationWarning,
-        )
-        return self.__enter__()
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        return self.__exit__(exc_type, exc_val, exc_tb)
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_eventloop.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_eventloop.py
index 7a899d8..a9c6e82 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_eventloop.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_eventloop.py
@@ -1,36 +1,37 @@
+from __future__ import annotations
+
 import math
 import sys
 import threading
+from collections.abc import Awaitable, Callable, Generator
 from contextlib import contextmanager
 from importlib import import_module
-from typing import (
-    Any,
-    Callable,
-    Coroutine,
-    Dict,
-    Generator,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-)
+from typing import TYPE_CHECKING, Any, TypeVar
 
 import sniffio
 
-# This must be updated when new backends are introduced
-from ._compat import DeprecatedAwaitableFloat
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if TYPE_CHECKING:
+    from ..abc import AsyncBackend
 
+# This must be updated when new backends are introduced
 BACKENDS = "asyncio", "trio"
 
 T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
 threadlocals = threading.local()
 
 
 def run(
-    func: Callable[..., Coroutine[Any, Any, T_Retval]],
-    *args: object,
+    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+    *args: Unpack[PosArgsT],
     backend: str = "asyncio",
-    backend_options: Optional[Dict[str, Any]] = None,
+    backend_options: dict[str, Any] | None = None,
 ) -> T_Retval:
     """
     Run the given coroutine function in an asynchronous event loop.
@@ -39,12 +40,13 @@ def run(
 
     :param func: a coroutine function
     :param args: positional arguments to ``func``
-    :param backend: name of the asynchronous event loop implementation – currently either
-        ``asyncio`` or ``trio``
-    :param backend_options: keyword arguments to call the backend ``run()`` implementation with
-        (documented :ref:`here <backend options>`)
+    :param backend: name of the asynchronous event loop implementation – currently
+        either ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()``
+        implementation with (documented :ref:`here <backend options>`)
     :return: the return value of the coroutine function
-    :raises RuntimeError: if an asynchronous event loop is already running in this thread
+    :raises RuntimeError: if an asynchronous event loop is already running in this
+        thread
     :raises LookupError: if the named backend is not found
 
     """
@@ -56,18 +58,19 @@ def run(
         raise RuntimeError(f"Already running {asynclib_name} in this thread")
 
     try:
-        asynclib = import_module(f"..._backends._{backend}", package=__name__)
+        async_backend = get_async_backend(backend)
     except ImportError as exc:
         raise LookupError(f"No such backend: {backend}") from exc
 
     token = None
     if sniffio.current_async_library_cvar.get(None) is None:
-        # Since we're in control of the event loop, we can cache the name of the async library
+        # Since we're in control of the event loop, we can cache the name of the async
+        # library
         token = sniffio.current_async_library_cvar.set(backend)
 
     try:
         backend_options = backend_options or {}
-        return asynclib.run(func, *args, **backend_options)  # type: ignore
+        return async_backend.run(func, args, {}, backend_options)
     finally:
         if token:
             sniffio.current_async_library_cvar.reset(token)
@@ -80,7 +83,7 @@ async def sleep(delay: float) -> None:
     :param delay: the duration, in seconds
 
     """
-    return await get_asynclib().sleep(delay)
+    return await get_async_backend().sleep(delay)
 
 
 async def sleep_forever() -> None:
@@ -99,8 +102,8 @@ async def sleep_until(deadline: float) -> None:
     """
     Pause the current task until the given time.
 
-    :param deadline: the absolute time to wake up at (according to the internal monotonic clock of
-        the event loop)
+    :param deadline: the absolute time to wake up at (according to the internal
+        monotonic clock of the event loop)
 
     .. versionadded:: 3.1
 
@@ -109,24 +112,24 @@ async def sleep_until(deadline: float) -> None:
     await sleep(max(deadline - now, 0))
 
 
-def current_time() -> DeprecatedAwaitableFloat:
+def current_time() -> float:
     """
     Return the current value of the event loop's internal clock.
 
     :return: the clock value (seconds)
 
     """
-    return DeprecatedAwaitableFloat(get_asynclib().current_time(), current_time)
+    return get_async_backend().current_time()
 
 
-def get_all_backends() -> Tuple[str, ...]:
+def get_all_backends() -> tuple[str, ...]:
     """Return a tuple of the names of all built-in backends."""
     return BACKENDS
 
 
-def get_cancelled_exc_class() -> Type[BaseException]:
+def get_cancelled_exc_class() -> type[BaseException]:
     """Return the current async library's cancellation exception class."""
-    return get_asynclib().CancelledError
+    return get_async_backend().cancelled_exception_class()
 
 
 #
@@ -135,23 +138,26 @@ def get_cancelled_exc_class() -> Type[BaseException]:
 
 
 @contextmanager
-def claim_worker_thread(backend: str) -> Generator[Any, None, None]:
-    module = sys.modules["anyio._backends._" + backend]
-    threadlocals.current_async_module = module
-    token = sniffio.current_async_library_cvar.set(backend)
+def claim_worker_thread(
+    backend_class: type[AsyncBackend], token: object
+) -> Generator[Any, None, None]:
+    threadlocals.current_async_backend = backend_class
+    threadlocals.current_token = token
     try:
         yield
     finally:
-        sniffio.current_async_library_cvar.reset(token)
-        del threadlocals.current_async_module
+        del threadlocals.current_async_backend
+        del threadlocals.current_token
 
 
-def get_asynclib(asynclib_name: Optional[str] = None) -> Any:
+def get_async_backend(asynclib_name: str | None = None) -> AsyncBackend:
     if asynclib_name is None:
         asynclib_name = sniffio.current_async_library()
 
     modulename = "anyio._backends._" + asynclib_name
     try:
-        return sys.modules[modulename]
+        module = sys.modules[modulename]
     except KeyError:
-        return import_module(modulename)
+        module = import_module(modulename)
+
+    return getattr(module, "backend_class")
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_exceptions.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_exceptions.py
index 4194ce2..571c3b8 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_exceptions.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_exceptions.py
@@ -1,23 +1,25 @@
-from traceback import format_exception
-from typing import Sequence
+from __future__ import annotations
 
 
 class BrokenResourceError(Exception):
     """
-    Raised when trying to use a resource that has been rendered unusuable due to external causes
-    (e.g. a send stream whose peer has disconnected).
+    Raised when trying to use a resource that has been rendered unusable due to external
+    causes (e.g. a send stream whose peer has disconnected).
     """
 
 
 class BrokenWorkerProcess(Exception):
     """
-    Raised by :func:`run_sync_in_process` if the worker process terminates abruptly or otherwise
-    misbehaves.
+    Raised by :func:`run_sync_in_process` if the worker process terminates abruptly or
+    otherwise misbehaves.
     """
 
 
 class BusyResourceError(Exception):
-    """Raised when two tasks are trying to read from or write to the same resource concurrently."""
+    """
+    Raised when two tasks are trying to read from or write to the same resource
+    concurrently.
+    """
 
     def __init__(self, action: str):
         super().__init__(f"Another task is already {action} this resource")
@@ -29,7 +31,8 @@ class ClosedResourceError(Exception):
 
 class DelimiterNotFound(Exception):
     """
-    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
     maximum number of bytes has been read without the delimiter being found.
     """
 
@@ -40,38 +43,15 @@ def __init__(self, max_bytes: int) -> None:
 
 
 class EndOfStream(Exception):
-    """Raised when trying to read from a stream that has been closed from the other end."""
-
-
-class ExceptionGroup(BaseException):
     """
-    Raised when multiple exceptions have been raised in a task group.
-
-    :var ~typing.Sequence[BaseException] exceptions: the sequence of exceptions raised together
+    Raised when trying to read from a stream that has been closed from the other end.
     """
 
-    SEPARATOR = "----------------------------\n"
-
-    exceptions: Sequence[BaseException]
-
-    def __str__(self) -> str:
-        tracebacks = [
-            "".join(format_exception(type(exc), exc, exc.__traceback__))
-            for exc in self.exceptions
-        ]
-        return (
-            f"{len(self.exceptions)} exceptions were raised in the task group:\n"
-            f"{self.SEPARATOR}{self.SEPARATOR.join(tracebacks)}"
-        )
-
-    def __repr__(self) -> str:
-        exception_reprs = ", ".join(repr(exc) for exc in self.exceptions)
-        return f"<{self.__class__.__name__}: {exception_reprs}>"
-
 
 class IncompleteRead(Exception):
     """
-    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
     :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
     connection is closed before the requested amount of bytes has been read.
     """
@@ -84,8 +64,8 @@ def __init__(self) -> None:
 
 class TypedAttributeLookupError(LookupError):
     """
-    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute is not
-    found and no default value has been given.
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute
+    is not found and no default value has been given.
     """
 
 
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_fileio.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_fileio.py
index 552995b..d054be6 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_fileio.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_fileio.py
@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import os
 import pathlib
 import sys
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import dataclass
 from functools import partial
 from os import PathLike
@@ -10,27 +13,14 @@
     Any,
     AnyStr,
     AsyncIterator,
-    Callable,
+    Final,
     Generic,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
-    cast,
     overload,
 )
 
 from .. import to_thread
 from ..abc import AsyncResource
 
-if sys.version_info >= (3, 8):
-    from typing import Final
-else:
-    from typing_extensions import Final
-
 if TYPE_CHECKING:
     from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
 else:
@@ -41,8 +31,8 @@ class AsyncFile(AsyncResource, Generic[AnyStr]):
     """
     An asynchronous file object.
 
-    This class wraps a standard file object and provides async friendly versions of the following
-    blocking methods (where available on the original file object):
+    This class wraps a standard file object and provides async friendly versions of the
+    following blocking methods (where available on the original file object):
 
     * read
     * read1
@@ -59,8 +49,8 @@ class AsyncFile(AsyncResource, Generic[AnyStr]):
 
     All other methods are directly passed through.
 
-    This class supports the asynchronous context manager protocol which closes the underlying file
-    at the end of the context block.
+    This class supports the asynchronous context manager protocol which closes the
+    underlying file at the end of the context block.
 
     This class also supports asynchronous iteration::
 
@@ -94,51 +84,49 @@ async def aclose(self) -> None:
     async def read(self, size: int = -1) -> AnyStr:
         return await to_thread.run_sync(self._fp.read, size)
 
-    async def read1(self: "AsyncFile[bytes]", size: int = -1) -> bytes:
+    async def read1(self: AsyncFile[bytes], size: int = -1) -> bytes:
         return await to_thread.run_sync(self._fp.read1, size)
 
     async def readline(self) -> AnyStr:
         return await to_thread.run_sync(self._fp.readline)
 
-    async def readlines(self) -> List[AnyStr]:
+    async def readlines(self) -> list[AnyStr]:
         return await to_thread.run_sync(self._fp.readlines)
 
-    async def readinto(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+    async def readinto(self: AsyncFile[bytes], b: WriteableBuffer) -> bytes:
         return await to_thread.run_sync(self._fp.readinto, b)
 
-    async def readinto1(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+    async def readinto1(self: AsyncFile[bytes], b: WriteableBuffer) -> bytes:
         return await to_thread.run_sync(self._fp.readinto1, b)
 
     @overload
-    async def write(self: "AsyncFile[bytes]", b: ReadableBuffer) -> int:
+    async def write(self: AsyncFile[bytes], b: ReadableBuffer) -> int:
         ...
 
     @overload
-    async def write(self: "AsyncFile[str]", b: str) -> int:
+    async def write(self: AsyncFile[str], b: str) -> int:
         ...
 
-    async def write(self, b: Union[ReadableBuffer, str]) -> int:
+    async def write(self, b: ReadableBuffer | str) -> int:
         return await to_thread.run_sync(self._fp.write, b)
 
     @overload
     async def writelines(
-        self: "AsyncFile[bytes]", lines: Iterable[ReadableBuffer]
+        self: AsyncFile[bytes], lines: Iterable[ReadableBuffer]
     ) -> None:
         ...
 
     @overload
-    async def writelines(self: "AsyncFile[str]", lines: Iterable[str]) -> None:
+    async def writelines(self: AsyncFile[str], lines: Iterable[str]) -> None:
         ...
 
-    async def writelines(
-        self, lines: Union[Iterable[ReadableBuffer], Iterable[str]]
-    ) -> None:
+    async def writelines(self, lines: Iterable[ReadableBuffer] | Iterable[str]) -> None:
         return await to_thread.run_sync(self._fp.writelines, lines)
 
-    async def truncate(self, size: Optional[int] = None) -> int:
+    async def truncate(self, size: int | None = None) -> int:
         return await to_thread.run_sync(self._fp.truncate, size)
 
-    async def seek(self, offset: int, whence: Optional[int] = os.SEEK_SET) -> int:
+    async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int:
         return await to_thread.run_sync(self._fp.seek, offset, whence)
 
     async def tell(self) -> int:
@@ -150,42 +138,42 @@ async def flush(self) -> None:
 
 @overload
 async def open_file(
-    file: Union[str, PathLike, int],
+    file: str | PathLike[str] | int,
     mode: OpenBinaryMode,
     buffering: int = ...,
-    encoding: Optional[str] = ...,
-    errors: Optional[str] = ...,
-    newline: Optional[str] = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
     closefd: bool = ...,
-    opener: Optional[Callable[[str, int], int]] = ...,
+    opener: Callable[[str, int], int] | None = ...,
 ) -> AsyncFile[bytes]:
     ...
 
 
 @overload
 async def open_file(
-    file: Union[str, PathLike, int],
+    file: str | PathLike[str] | int,
     mode: OpenTextMode = ...,
     buffering: int = ...,
-    encoding: Optional[str] = ...,
-    errors: Optional[str] = ...,
-    newline: Optional[str] = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
     closefd: bool = ...,
-    opener: Optional[Callable[[str, int], int]] = ...,
+    opener: Callable[[str, int], int] | None = ...,
 ) -> AsyncFile[str]:
     ...
 
 
 async def open_file(
-    file: Union[str, PathLike, int],
+    file: str | PathLike[str] | int,
     mode: str = "r",
     buffering: int = -1,
-    encoding: Optional[str] = None,
-    errors: Optional[str] = None,
-    newline: Optional[str] = None,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
     closefd: bool = True,
-    opener: Optional[Callable[[str, int], int]] = None,
-) -> AsyncFile:
+    opener: Callable[[str, int], int] | None = None,
+) -> AsyncFile[Any]:
     """
     Open a file asynchronously.
 
@@ -213,25 +201,28 @@ def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]:
 
 @dataclass(eq=False)
 class _PathIterator(AsyncIterator["Path"]):
-    iterator: Iterator[PathLike]
+    iterator: Iterator[PathLike[str]]
 
-    async def __anext__(self) -> "Path":
-        nextval = await to_thread.run_sync(next, self.iterator, None, cancellable=True)
+    async def __anext__(self) -> Path:
+        nextval = await to_thread.run_sync(
+            next, self.iterator, None, abandon_on_cancel=True
+        )
         if nextval is None:
             raise StopAsyncIteration from None
 
-        return Path(cast(PathLike, nextval))
+        return Path(nextval)
 
 
 class Path:
     """
     An asynchronous version of :class:`pathlib.Path`.
 
-    This class cannot be substituted for :class:`pathlib.Path` or :class:`pathlib.PurePath`, but
-    it is compatible with the :class:`os.PathLike` interface.
+    This class cannot be substituted for :class:`pathlib.Path` or
+    :class:`pathlib.PurePath`, but it is compatible with the :class:`os.PathLike`
+    interface.
 
-    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for the
-    deprecated :meth:`~pathlib.Path.link_to` method.
+    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for
+    the deprecated :meth:`~pathlib.Path.link_to` method.
 
     Any methods that do disk I/O need to be awaited on. These methods are:
 
@@ -267,7 +258,8 @@ class Path:
     * :meth:`~pathlib.Path.write_bytes`
     * :meth:`~pathlib.Path.write_text`
 
-    Additionally, the following methods return an async iterator yielding :class:`~.Path` objects:
+    Additionally, the following methods return an async iterator yielding
+    :class:`~.Path` objects:
 
     * :meth:`~pathlib.Path.glob`
     * :meth:`~pathlib.Path.iterdir`
@@ -276,7 +268,9 @@ class Path:
 
     __slots__ = "_path", "__weakref__"
 
-    def __init__(self, *args: Union[str, PathLike]) -> None:
+    __weakref__: Any
+
+    def __init__(self, *args: str | PathLike[str]) -> None:
         self._path: Final[pathlib.Path] = pathlib.Path(*args)
 
     def __fspath__(self) -> str:
@@ -298,30 +292,30 @@ def __eq__(self, other: object) -> bool:
         target = other._path if isinstance(other, Path) else other
         return self._path.__eq__(target)
 
-    def __lt__(self, other: "Path") -> bool:
+    def __lt__(self, other: pathlib.PurePath | Path) -> bool:
         target = other._path if isinstance(other, Path) else other
         return self._path.__lt__(target)
 
-    def __le__(self, other: "Path") -> bool:
+    def __le__(self, other: pathlib.PurePath | Path) -> bool:
         target = other._path if isinstance(other, Path) else other
         return self._path.__le__(target)
 
-    def __gt__(self, other: "Path") -> bool:
+    def __gt__(self, other: pathlib.PurePath | Path) -> bool:
         target = other._path if isinstance(other, Path) else other
         return self._path.__gt__(target)
 
-    def __ge__(self, other: "Path") -> bool:
+    def __ge__(self, other: pathlib.PurePath | Path) -> bool:
         target = other._path if isinstance(other, Path) else other
         return self._path.__ge__(target)
 
-    def __truediv__(self, other: Any) -> "Path":
+    def __truediv__(self, other: str | PathLike[str]) -> Path:
         return Path(self._path / other)
 
-    def __rtruediv__(self, other: Any) -> "Path":
+    def __rtruediv__(self, other: str | PathLike[str]) -> Path:
         return Path(other) / self
 
     @property
-    def parts(self) -> Tuple[str, ...]:
+    def parts(self) -> tuple[str, ...]:
         return self._path.parts
 
     @property
@@ -337,11 +331,11 @@ def anchor(self) -> str:
         return self._path.anchor
 
     @property
-    def parents(self) -> Sequence["Path"]:
+    def parents(self) -> Sequence[Path]:
         return tuple(Path(p) for p in self._path.parents)
 
     @property
-    def parent(self) -> "Path":
+    def parent(self) -> Path:
         return Path(self._path.parent)
 
     @property
@@ -353,14 +347,14 @@ def suffix(self) -> str:
         return self._path.suffix
 
     @property
-    def suffixes(self) -> List[str]:
+    def suffixes(self) -> list[str]:
         return self._path.suffixes
 
     @property
     def stem(self) -> str:
         return self._path.stem
 
-    async def absolute(self) -> "Path":
+    async def absolute(self) -> Path:
         path = await to_thread.run_sync(self._path.absolute)
         return Path(path)
 
@@ -373,43 +367,50 @@ def as_uri(self) -> str:
     def match(self, path_pattern: str) -> bool:
         return self._path.match(path_pattern)
 
-    def is_relative_to(self, *other: Union[str, PathLike]) -> bool:
+    def is_relative_to(self, other: str | PathLike[str]) -> bool:
         try:
-            self.relative_to(*other)
+            self.relative_to(other)
             return True
         except ValueError:
             return False
 
+    async def is_junction(self) -> bool:
+        return await to_thread.run_sync(self._path.is_junction)
+
     async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None:
         func = partial(os.chmod, follow_symlinks=follow_symlinks)
         return await to_thread.run_sync(func, self._path, mode)
 
     @classmethod
-    async def cwd(cls) -> "Path":
+    async def cwd(cls) -> Path:
         path = await to_thread.run_sync(pathlib.Path.cwd)
         return cls(path)
 
     async def exists(self) -> bool:
-        return await to_thread.run_sync(self._path.exists, cancellable=True)
+        return await to_thread.run_sync(self._path.exists, abandon_on_cancel=True)
 
-    async def expanduser(self) -> "Path":
-        return Path(await to_thread.run_sync(self._path.expanduser, cancellable=True))
+    async def expanduser(self) -> Path:
+        return Path(
+            await to_thread.run_sync(self._path.expanduser, abandon_on_cancel=True)
+        )
 
-    def glob(self, pattern: str) -> AsyncIterator["Path"]:
+    def glob(self, pattern: str) -> AsyncIterator[Path]:
         gen = self._path.glob(pattern)
         return _PathIterator(gen)
 
     async def group(self) -> str:
-        return await to_thread.run_sync(self._path.group, cancellable=True)
+        return await to_thread.run_sync(self._path.group, abandon_on_cancel=True)
 
-    async def hardlink_to(self, target: Union[str, pathlib.Path, "Path"]) -> None:
+    async def hardlink_to(
+        self, target: str | bytes | PathLike[str] | PathLike[bytes]
+    ) -> None:
         if isinstance(target, Path):
             target = target._path
 
         await to_thread.run_sync(os.link, target, self)
 
     @classmethod
-    async def home(cls) -> "Path":
+    async def home(cls) -> Path:
         home_path = await to_thread.run_sync(pathlib.Path.home)
         return cls(home_path)
 
@@ -417,44 +418,50 @@ def is_absolute(self) -> bool:
         return self._path.is_absolute()
 
     async def is_block_device(self) -> bool:
-        return await to_thread.run_sync(self._path.is_block_device, cancellable=True)
+        return await to_thread.run_sync(
+            self._path.is_block_device, abandon_on_cancel=True
+        )
 
     async def is_char_device(self) -> bool:
-        return await to_thread.run_sync(self._path.is_char_device, cancellable=True)
+        return await to_thread.run_sync(
+            self._path.is_char_device, abandon_on_cancel=True
+        )
 
     async def is_dir(self) -> bool:
-        return await to_thread.run_sync(self._path.is_dir, cancellable=True)
+        return await to_thread.run_sync(self._path.is_dir, abandon_on_cancel=True)
 
     async def is_fifo(self) -> bool:
-        return await to_thread.run_sync(self._path.is_fifo, cancellable=True)
+        return await to_thread.run_sync(self._path.is_fifo, abandon_on_cancel=True)
 
     async def is_file(self) -> bool:
-        return await to_thread.run_sync(self._path.is_file, cancellable=True)
+        return await to_thread.run_sync(self._path.is_file, abandon_on_cancel=True)
 
     async def is_mount(self) -> bool:
-        return await to_thread.run_sync(os.path.ismount, self._path, cancellable=True)
+        return await to_thread.run_sync(
+            os.path.ismount, self._path, abandon_on_cancel=True
+        )
 
     def is_reserved(self) -> bool:
         return self._path.is_reserved()
 
     async def is_socket(self) -> bool:
-        return await to_thread.run_sync(self._path.is_socket, cancellable=True)
+        return await to_thread.run_sync(self._path.is_socket, abandon_on_cancel=True)
 
     async def is_symlink(self) -> bool:
-        return await to_thread.run_sync(self._path.is_symlink, cancellable=True)
+        return await to_thread.run_sync(self._path.is_symlink, abandon_on_cancel=True)
 
-    def iterdir(self) -> AsyncIterator["Path"]:
+    def iterdir(self) -> AsyncIterator[Path]:
         gen = self._path.iterdir()
         return _PathIterator(gen)
 
-    def joinpath(self, *args: Union[str, "PathLike[str]"]) -> "Path":
+    def joinpath(self, *args: str | PathLike[str]) -> Path:
         return Path(self._path.joinpath(*args))
 
     async def lchmod(self, mode: int) -> None:
         await to_thread.run_sync(self._path.lchmod, mode)
 
     async def lstat(self) -> os.stat_result:
-        return await to_thread.run_sync(self._path.lstat, cancellable=True)
+        return await to_thread.run_sync(self._path.lstat, abandon_on_cancel=True)
 
     async def mkdir(
         self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
@@ -466,9 +473,9 @@ async def open(
         self,
         mode: OpenBinaryMode,
         buffering: int = ...,
-        encoding: Optional[str] = ...,
-        errors: Optional[str] = ...,
-        newline: Optional[str] = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
     ) -> AsyncFile[bytes]:
         ...
 
@@ -477,9 +484,9 @@ async def open(
         self,
         mode: OpenTextMode = ...,
         buffering: int = ...,
-        encoding: Optional[str] = ...,
-        errors: Optional[str] = ...,
-        newline: Optional[str] = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
     ) -> AsyncFile[str]:
         ...
 
@@ -487,75 +494,82 @@ async def open(
         self,
         mode: str = "r",
         buffering: int = -1,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
-    ) -> AsyncFile:
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> AsyncFile[Any]:
         fp = await to_thread.run_sync(
             self._path.open, mode, buffering, encoding, errors, newline
         )
         return AsyncFile(fp)
 
     async def owner(self) -> str:
-        return await to_thread.run_sync(self._path.owner, cancellable=True)
+        return await to_thread.run_sync(self._path.owner, abandon_on_cancel=True)
 
     async def read_bytes(self) -> bytes:
         return await to_thread.run_sync(self._path.read_bytes)
 
     async def read_text(
-        self, encoding: Optional[str] = None, errors: Optional[str] = None
+        self, encoding: str | None = None, errors: str | None = None
     ) -> str:
         return await to_thread.run_sync(self._path.read_text, encoding, errors)
 
-    def relative_to(self, *other: Union[str, PathLike]) -> "Path":
-        return Path(self._path.relative_to(*other))
+    if sys.version_info >= (3, 12):
 
-    async def readlink(self) -> "Path":
+        def relative_to(
+            self, *other: str | PathLike[str], walk_up: bool = False
+        ) -> Path:
+            return Path(self._path.relative_to(*other, walk_up=walk_up))
+
+    else:
+
+        def relative_to(self, *other: str | PathLike[str]) -> Path:
+            return Path(self._path.relative_to(*other))
+
+    async def readlink(self) -> Path:
         target = await to_thread.run_sync(os.readlink, self._path)
-        return Path(cast(str, target))
+        return Path(target)
 
-    async def rename(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+    async def rename(self, target: str | pathlib.PurePath | Path) -> Path:
         if isinstance(target, Path):
             target = target._path
 
         await to_thread.run_sync(self._path.rename, target)
         return Path(target)
 
-    async def replace(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+    async def replace(self, target: str | pathlib.PurePath | Path) -> Path:
         if isinstance(target, Path):
             target = target._path
 
         await to_thread.run_sync(self._path.replace, target)
         return Path(target)
 
-    async def resolve(self, strict: bool = False) -> "Path":
+    async def resolve(self, strict: bool = False) -> Path:
         func = partial(self._path.resolve, strict=strict)
-        return Path(await to_thread.run_sync(func, cancellable=True))
+        return Path(await to_thread.run_sync(func, abandon_on_cancel=True))
 
-    def rglob(self, pattern: str) -> AsyncIterator["Path"]:
+    def rglob(self, pattern: str) -> AsyncIterator[Path]:
         gen = self._path.rglob(pattern)
         return _PathIterator(gen)
 
     async def rmdir(self) -> None:
         await to_thread.run_sync(self._path.rmdir)
 
-    async def samefile(
-        self, other_path: Union[str, bytes, int, pathlib.Path, "Path"]
-    ) -> bool:
+    async def samefile(self, other_path: str | PathLike[str]) -> bool:
         if isinstance(other_path, Path):
             other_path = other_path._path
 
         return await to_thread.run_sync(
-            self._path.samefile, other_path, cancellable=True
+            self._path.samefile, other_path, abandon_on_cancel=True
         )
 
     async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result:
         func = partial(os.stat, follow_symlinks=follow_symlinks)
-        return await to_thread.run_sync(func, self._path, cancellable=True)
+        return await to_thread.run_sync(func, self._path, abandon_on_cancel=True)
 
     async def symlink_to(
         self,
-        target: Union[str, pathlib.Path, "Path"],
+        target: str | bytes | PathLike[str] | PathLike[bytes],
         target_is_directory: bool = False,
     ) -> None:
         if isinstance(target, Path):
@@ -573,24 +587,50 @@ async def unlink(self, missing_ok: bool = False) -> None:
             if not missing_ok:
                 raise
 
-    def with_name(self, name: str) -> "Path":
+    if sys.version_info >= (3, 12):
+
+        async def walk(
+            self,
+            top_down: bool = True,
+            on_error: Callable[[OSError], object] | None = None,
+            follow_symlinks: bool = False,
+        ) -> AsyncIterator[tuple[Path, list[str], list[str]]]:
+            def get_next_value() -> tuple[pathlib.Path, list[str], list[str]] | None:
+                try:
+                    return next(gen)
+                except StopIteration:
+                    return None
+
+            gen = self._path.walk(top_down, on_error, follow_symlinks)
+            while True:
+                value = await to_thread.run_sync(get_next_value)
+                if value is None:
+                    return
+
+                root, dirs, paths = value
+                yield Path(root), dirs, paths
+
+    def with_name(self, name: str) -> Path:
         return Path(self._path.with_name(name))
 
-    def with_stem(self, stem: str) -> "Path":
+    def with_stem(self, stem: str) -> Path:
         return Path(self._path.with_name(stem + self._path.suffix))
 
-    def with_suffix(self, suffix: str) -> "Path":
+    def with_suffix(self, suffix: str) -> Path:
         return Path(self._path.with_suffix(suffix))
 
+    def with_segments(self, *pathsegments: str | PathLike[str]) -> Path:
+        return Path(*pathsegments)
+
     async def write_bytes(self, data: bytes) -> int:
         return await to_thread.run_sync(self._path.write_bytes, data)
 
     async def write_text(
         self,
         data: str,
-        encoding: Optional[str] = None,
-        errors: Optional[str] = None,
-        newline: Optional[str] = None,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
     ) -> int:
         # Path.write_text() does not support the "newline" parameter before Python 3.10
         def sync_write_text() -> int:
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_resources.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_resources.py
index b9414f7..b9a5344 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_resources.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_resources.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from ..abc import AsyncResource
 from ._tasks import CancelScope
 
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_signals.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_signals.py
index 02234fd..115c749 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_signals.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_signals.py
@@ -1,24 +1,25 @@
-from typing import AsyncIterator
+from __future__ import annotations
 
-from ._compat import DeprecatedAsyncContextManager
-from ._eventloop import get_asynclib
+from collections.abc import AsyncIterator
+from signal import Signals
+from typing import ContextManager
 
+from ._eventloop import get_async_backend
 
-def open_signal_receiver(
-    *signals: int,
-) -> DeprecatedAsyncContextManager[AsyncIterator[int]]:
+
+def open_signal_receiver(*signals: Signals) -> ContextManager[AsyncIterator[Signals]]:
     """
     Start receiving operating system signals.
 
     :param signals: signals to receive (e.g. ``signal.SIGINT``)
-    :return: an asynchronous context manager for an asynchronous iterator which yields signal
-        numbers
+    :return: an asynchronous context manager for an asynchronous iterator which yields
+        signal numbers
 
-    .. warning:: Windows does not support signals natively so it is best to avoid relying on this
-        in cross-platform applications.
+    .. warning:: Windows does not support signals natively so it is best to avoid
+        relying on this in cross-platform applications.
 
-    .. warning:: On asyncio, this permanently replaces any previous signal handler for the given
-        signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
+    .. warning:: On asyncio, this permanently replaces any previous signal handler for
+        the given signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
 
     """
-    return get_asynclib().open_signal_receiver(*signals)
+    return get_async_backend().open_signal_receiver(*signals)
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_sockets.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_sockets.py
index 62c6007..0f0a314 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_sockets.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_sockets.py
@@ -1,39 +1,41 @@
+from __future__ import annotations
+
+import errno
+import os
 import socket
 import ssl
+import stat
 import sys
+from collections.abc import Awaitable
 from ipaddress import IPv6Address, ip_address
 from os import PathLike, chmod
-from pathlib import Path
 from socket import AddressFamily, SocketKind
-from typing import Awaitable, List, Optional, Tuple, Union, cast, overload
+from typing import Any, Literal, cast, overload
 
 from .. import to_thread
 from ..abc import (
     ConnectedUDPSocket,
+    ConnectedUNIXDatagramSocket,
     IPAddressType,
     IPSockAddrType,
     SocketListener,
     SocketStream,
     UDPSocket,
+    UNIXDatagramSocket,
     UNIXSocketStream,
 )
 from ..streams.stapled import MultiListener
 from ..streams.tls import TLSStream
-from ._eventloop import get_asynclib
+from ._eventloop import get_async_backend
 from ._resources import aclose_forcefully
 from ._synchronization import Event
 from ._tasks import create_task_group, move_on_after
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
 
 IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41)  # https://bugs.python.org/issue29515
 
-GetAddrInfoReturnType = List[
-    Tuple[AddressFamily, SocketKind, int, str, Tuple[str, int]]
-]
 AnyIPAddressFamily = Literal[
     AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6
 ]
@@ -46,8 +48,8 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = ...,
-    ssl_context: Optional[ssl.SSLContext] = ...,
+    local_host: IPAddressType | None = ...,
+    ssl_context: ssl.SSLContext | None = ...,
     tls_standard_compatible: bool = ...,
     tls_hostname: str,
     happy_eyeballs_delay: float = ...,
@@ -61,10 +63,10 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = ...,
+    local_host: IPAddressType | None = ...,
     ssl_context: ssl.SSLContext,
     tls_standard_compatible: bool = ...,
-    tls_hostname: Optional[str] = ...,
+    tls_hostname: str | None = ...,
     happy_eyeballs_delay: float = ...,
 ) -> TLSStream:
     ...
@@ -76,11 +78,11 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = ...,
+    local_host: IPAddressType | None = ...,
     tls: Literal[True],
-    ssl_context: Optional[ssl.SSLContext] = ...,
+    ssl_context: ssl.SSLContext | None = ...,
     tls_standard_compatible: bool = ...,
-    tls_hostname: Optional[str] = ...,
+    tls_hostname: str | None = ...,
     happy_eyeballs_delay: float = ...,
 ) -> TLSStream:
     ...
@@ -92,11 +94,11 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = ...,
+    local_host: IPAddressType | None = ...,
     tls: Literal[False],
-    ssl_context: Optional[ssl.SSLContext] = ...,
+    ssl_context: ssl.SSLContext | None = ...,
     tls_standard_compatible: bool = ...,
-    tls_hostname: Optional[str] = ...,
+    tls_hostname: str | None = ...,
     happy_eyeballs_delay: float = ...,
 ) -> SocketStream:
     ...
@@ -108,7 +110,7 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = ...,
+    local_host: IPAddressType | None = ...,
     happy_eyeballs_delay: float = ...,
 ) -> SocketStream:
     ...
@@ -118,45 +120,49 @@ async def connect_tcp(
     remote_host: IPAddressType,
     remote_port: int,
     *,
-    local_host: Optional[IPAddressType] = None,
+    local_host: IPAddressType | None = None,
     tls: bool = False,
-    ssl_context: Optional[ssl.SSLContext] = None,
+    ssl_context: ssl.SSLContext | None = None,
     tls_standard_compatible: bool = True,
-    tls_hostname: Optional[str] = None,
+    tls_hostname: str | None = None,
     happy_eyeballs_delay: float = 0.25,
-) -> Union[SocketStream, TLSStream]:
+) -> SocketStream | TLSStream:
     """
     Connect to a host using the TCP protocol.
 
-    This function implements the stateless version of the Happy Eyeballs algorithm (RFC 6555).
-    If ``address`` is a host name that resolves to multiple IP addresses, each one is tried until
-    one connection attempt succeeds. If the first attempt does not connected within 250
-    milliseconds, a second attempt is started using the next address in the list, and so on.
-    On IPv6 enabled systems, an IPv6 address (if available) is tried first.
+    This function implements the stateless version of the Happy Eyeballs algorithm (RFC
+    6555). If ``remote_host`` is a host name that resolves to multiple IP addresses,
+    each one is tried until one connection attempt succeeds. If the first attempt does
+    not connected within 250 milliseconds, a second attempt is started using the next
+    address in the list, and so on. On IPv6 enabled systems, an IPv6 address (if
+    available) is tried first.
 
     When the connection has been established, a TLS handshake will be done if either
     ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``.
 
     :param remote_host: the IP address or host name to connect to
     :param remote_port: port on the target host to connect to
-    :param local_host: the interface address or name to bind the socket to before connecting
+    :param local_host: the interface address or name to bind the socket to before
+        connecting
     :param tls: ``True`` to do a TLS handshake with the connected stream and return a
         :class:`~anyio.streams.tls.TLSStream` instead
-    :param ssl_context: the SSL context object to use (if omitted, a default context is created)
-    :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake before closing
-        the stream and requires that the server does this as well. Otherwise,
-        :exc:`~ssl.SSLEOFError` may be raised during reads from the stream.
+    :param ssl_context: the SSL context object to use (if omitted, a default context is
+        created)
+    :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake
+        before closing the stream and requires that the server does this as well.
+        Otherwise, :exc:`~ssl.SSLEOFError` may be raised during reads from the stream.
         Some protocols, such as HTTP, require this option to be ``False``.
         See :meth:`~ssl.SSLContext.wrap_socket` for details.
-    :param tls_hostname: host name to check the server certificate against (defaults to the value
-        of ``remote_host``)
-    :param happy_eyeballs_delay: delay (in seconds) before starting the next connection attempt
+    :param tls_hostname: host name to check the server certificate against (defaults to
+        the value of ``remote_host``)
+    :param happy_eyeballs_delay: delay (in seconds) before starting the next connection
+        attempt
     :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream
     :raises OSError: if the connection attempt fails
 
     """
     # Placed here due to https://github.com/python/mypy/issues/7057
-    connected_stream: Optional[SocketStream] = None
+    connected_stream: SocketStream | None = None
 
     async def try_connect(remote_host: str, event: Event) -> None:
         nonlocal connected_stream
@@ -174,8 +180,8 @@ async def try_connect(remote_host: str, event: Event) -> None:
         finally:
             event.set()
 
-    asynclib = get_asynclib()
-    local_address: Optional[IPSockAddrType] = None
+    asynclib = get_async_backend()
+    local_address: IPSockAddrType | None = None
     family = socket.AF_UNSPEC
     if local_host:
         gai_res = await getaddrinfo(str(local_host), None)
@@ -190,10 +196,10 @@ async def try_connect(remote_host: str, event: Event) -> None:
             target_host, remote_port, family=family, type=socket.SOCK_STREAM
         )
 
-        # Organize the list so that the first address is an IPv6 address (if available) and the
-        # second one is an IPv4 addresses. The rest can be in whatever order.
+        # Organize the list so that the first address is an IPv6 address (if available)
+        # and the second one is an IPv4 addresses. The rest can be in whatever order.
         v6_found = v4_found = False
-        target_addrs: List[Tuple[socket.AddressFamily, str]] = []
+        target_addrs: list[tuple[socket.AddressFamily, str]] = []
         for af, *rest, sa in gai_res:
             if af == socket.AF_INET6 and not v6_found:
                 v6_found = True
@@ -209,7 +215,7 @@ async def try_connect(remote_host: str, event: Event) -> None:
         else:
             target_addrs = [(socket.AF_INET, addr_obj.compressed)]
 
-    oserrors: List[OSError] = []
+    oserrors: list[OSError] = []
     async with create_task_group() as tg:
         for i, (af, addr) in enumerate(target_addrs):
             event = Event()
@@ -218,7 +224,11 @@ async def try_connect(remote_host: str, event: Event) -> None:
                 await event.wait()
 
     if connected_stream is None:
-        cause = oserrors[0] if len(oserrors) == 1 else asynclib.ExceptionGroup(oserrors)
+        cause = (
+            oserrors[0]
+            if len(oserrors) == 1
+            else ExceptionGroup("multiple connection attempts failed", oserrors)
+        )
         raise OSError("All connection attempts failed") from cause
 
     if tls or tls_hostname or ssl_context:
@@ -237,7 +247,7 @@ async def try_connect(remote_host: str, event: Event) -> None:
     return connected_stream
 
 
-async def connect_unix(path: Union[str, PathLike]) -> UNIXSocketStream:
+async def connect_unix(path: str | bytes | PathLike[Any]) -> UNIXSocketStream:
     """
     Connect to the given UNIX socket.
 
@@ -247,13 +257,13 @@ async def connect_unix(path: Union[str, PathLike]) -> UNIXSocketStream:
     :return: a socket stream object
 
     """
-    path = str(Path(path))
-    return await get_asynclib().connect_unix(path)
+    path = os.fspath(path)
+    return await get_async_backend().connect_unix(path)
 
 
 async def create_tcp_listener(
     *,
-    local_host: Optional[IPAddressType] = None,
+    local_host: IPAddressType | None = None,
     local_port: int = 0,
     family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC,
     backlog: int = 65536,
@@ -263,36 +273,44 @@ async def create_tcp_listener(
     Create a TCP socket listener.
 
     :param local_port: port number to listen on
-    :param local_host: IP address of the interface to listen on. If omitted, listen on all IPv4
-        and IPv6 interfaces. To listen on all interfaces on a specific address family, use
-        ``0.0.0.0`` for IPv4 or ``::`` for IPv6.
-    :param family: address family (used if ``interface`` was omitted)
-    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
-        65536)
-    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
-        (not supported on Windows)
+    :param local_host: IP address of the interface to listen on. If omitted, listen on
+        all IPv4 and IPv6 interfaces. To listen on all interfaces on a specific address
+        family, use ``0.0.0.0`` for IPv4 or ``::`` for IPv6.
+    :param family: address family (used if ``local_host`` was omitted)
+    :param backlog: maximum number of queued incoming connections (up to a maximum of
+        2**16, or 65536)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
     :return: a list of listener objects
 
     """
-    asynclib = get_asynclib()
+    asynclib = get_async_backend()
     backlog = min(backlog, 65536)
     local_host = str(local_host) if local_host is not None else None
     gai_res = await getaddrinfo(
         local_host,
         local_port,
-        family=family,  # type: ignore[arg-type]
-        type=socket.SOCK_STREAM,
+        family=family,
+        type=socket.SocketKind.SOCK_STREAM if sys.platform == "win32" else 0,
         flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
     )
-    listeners: List[SocketListener] = []
+    listeners: list[SocketListener] = []
     try:
         # The set() is here to work around a glibc bug:
         # https://sourceware.org/bugzilla/show_bug.cgi?id=14969
-        for fam, *_, sockaddr in sorted(set(gai_res)):
+        sockaddr: tuple[str, int] | tuple[str, int, int, int]
+        for fam, kind, *_, sockaddr in sorted(set(gai_res)):
+            # Workaround for an uvloop bug where we don't get the correct scope ID for
+            # IPv6 link-local addresses when passing type=socket.SOCK_STREAM to
+            # getaddrinfo(): https://github.com/MagicStack/uvloop/issues/539
+            if sys.platform != "win32" and kind is not SocketKind.SOCK_STREAM:
+                continue
+
             raw_socket = socket.socket(fam)
             raw_socket.setblocking(False)
 
-            # For Windows, enable exclusive address use. For others, enable address reuse.
+            # For Windows, enable exclusive address use. For others, enable address
+            # reuse.
             if sys.platform == "win32":
                 raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
             else:
@@ -305,9 +323,14 @@ async def create_tcp_listener(
             if fam == socket.AF_INET6:
                 raw_socket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
 
+                # Workaround for #554
+                if "%" in sockaddr[0]:
+                    addr, scope_id = sockaddr[0].split("%", 1)
+                    sockaddr = (addr, sockaddr[1], 0, int(scope_id))
+
             raw_socket.bind(sockaddr)
             raw_socket.listen(backlog)
-            listener = asynclib.TCPSocketListener(raw_socket)
+            listener = asynclib.create_tcp_listener(raw_socket)
             listeners.append(listener)
     except BaseException:
         for listener in listeners:
@@ -319,7 +342,10 @@ async def create_tcp_listener(
 
 
 async def create_unix_listener(
-    path: Union[str, PathLike], *, mode: Optional[int] = None, backlog: int = 65536
+    path: str | bytes | PathLike[Any],
+    *,
+    mode: int | None = None,
+    backlog: int = 65536,
 ) -> SocketListener:
     """
     Create a UNIX socket listener.
@@ -328,29 +354,20 @@ async def create_unix_listener(
 
     :param path: path of the socket
     :param mode: permissions to set on the socket
-    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
-        65536)
+    :param backlog: maximum number of queued incoming connections (up to a maximum of
+        2**16, or 65536)
     :return: a listener object
 
     .. versionchanged:: 3.0
-        If a socket already exists on the file system in the given path, it will be removed first.
+        If a socket already exists on the file system in the given path, it will be
+        removed first.
 
     """
-    path_str = str(path)
-    path = Path(path)
-    if path.is_socket():
-        path.unlink()
-
     backlog = min(backlog, 65536)
-    raw_socket = socket.socket(socket.AF_UNIX)
-    raw_socket.setblocking(False)
+    raw_socket = await setup_unix_local_socket(path, mode, socket.SOCK_STREAM)
     try:
-        await to_thread.run_sync(raw_socket.bind, path_str, cancellable=True)
-        if mode is not None:
-            await to_thread.run_sync(chmod, path_str, mode, cancellable=True)
-
         raw_socket.listen(backlog)
-        return get_asynclib().UNIXSocketListener(raw_socket)
+        return get_async_backend().create_unix_listener(raw_socket)
     except BaseException:
         raw_socket.close()
         raise
@@ -359,29 +376,28 @@ async def create_unix_listener(
 async def create_udp_socket(
     family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
     *,
-    local_host: Optional[IPAddressType] = None,
+    local_host: IPAddressType | None = None,
     local_port: int = 0,
     reuse_port: bool = False,
 ) -> UDPSocket:
     """
     Create a UDP socket.
 
-    If ``port`` has been given, the socket will be bound to this port on the local machine,
-    making this socket suitable for providing UDP based services.
+    If ``port`` has been given, the socket will be bound to this port on the local
+    machine, making this socket suitable for providing UDP based services.
 
-    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
-        ``local_host`` if omitted
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically
+        determined from ``local_host`` if omitted
     :param local_host: IP address or host name of the local interface to bind to
     :param local_port: local port to bind to
-    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
-        (not supported on Windows)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
     :return: a UDP socket
 
     """
     if family is AddressFamily.AF_UNSPEC and not local_host:
         raise ValueError('Either "family" or "local_host" must be given')
 
-    local_address: Optional[IPSockAddrType] = None
     if local_host:
         gai_res = await getaddrinfo(
             str(local_host),
@@ -392,10 +408,15 @@ async def create_udp_socket(
         )
         family = cast(AnyIPAddressFamily, gai_res[0][0])
         local_address = gai_res[0][-1]
+    elif family is AddressFamily.AF_INET6:
+        local_address = ("::", 0)
+    else:
+        local_address = ("0.0.0.0", 0)
 
-    return await get_asynclib().create_udp_socket(
+    sock = await get_async_backend().create_udp_socket(
         family, local_address, None, reuse_port
     )
+    return cast(UDPSocket, sock)
 
 
 async def create_connected_udp_socket(
@@ -403,24 +424,24 @@ async def create_connected_udp_socket(
     remote_port: int,
     *,
     family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
-    local_host: Optional[IPAddressType] = None,
+    local_host: IPAddressType | None = None,
     local_port: int = 0,
     reuse_port: bool = False,
 ) -> ConnectedUDPSocket:
     """
     Create a connected UDP socket.
 
-    Connected UDP sockets can only communicate with the specified remote host/port, and any packets
-    sent from other sources are dropped.
+    Connected UDP sockets can only communicate with the specified remote host/port, an
+    any packets sent from other sources are dropped.
 
     :param remote_host: remote host to set as the default target
     :param remote_port: port on the remote host to set as the default target
-    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
-        ``local_host`` or ``remote_host`` if omitted
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically
+        determined from ``local_host`` or ``remote_host`` if omitted
     :param local_host: IP address or host name of the local interface to bind to
     :param local_port: local port to bind to
-    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
-        (not supported on Windows)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
     :return: a connected UDP socket
 
     """
@@ -442,25 +463,87 @@ async def create_connected_udp_socket(
     family = cast(AnyIPAddressFamily, gai_res[0][0])
     remote_address = gai_res[0][-1]
 
-    return await get_asynclib().create_udp_socket(
+    sock = await get_async_backend().create_udp_socket(
         family, local_address, remote_address, reuse_port
     )
+    return cast(ConnectedUDPSocket, sock)
+
+
+async def create_unix_datagram_socket(
+    *,
+    local_path: None | str | bytes | PathLike[Any] = None,
+    local_mode: int | None = None,
+) -> UNIXDatagramSocket:
+    """
+    Create a UNIX datagram socket.
+
+    Not available on Windows.
+
+    If ``local_path`` has been given, the socket will be bound to this path, making this
+    socket suitable for receiving datagrams from other processes. Other processes can
+    send datagrams to this socket only if ``local_path`` is set.
+
+    If a socket already exists on the file system in the ``local_path``, it will be
+    removed first.
+
+    :param local_path: the path on which to bind to
+    :param local_mode: permissions to set on the local socket
+    :return: a UNIX datagram socket
+
+    """
+    raw_socket = await setup_unix_local_socket(
+        local_path, local_mode, socket.SOCK_DGRAM
+    )
+    return await get_async_backend().create_unix_datagram_socket(raw_socket, None)
+
+
+async def create_connected_unix_datagram_socket(
+    remote_path: str | bytes | PathLike[Any],
+    *,
+    local_path: None | str | bytes | PathLike[Any] = None,
+    local_mode: int | None = None,
+) -> ConnectedUNIXDatagramSocket:
+    """
+    Create a connected UNIX datagram socket.
+
+    Connected datagram sockets can only communicate with the specified remote path.
+
+    If ``local_path`` has been given, the socket will be bound to this path, making
+    this socket suitable for receiving datagrams from other processes. Other processes
+    can send datagrams to this socket only if ``local_path`` is set.
+
+    If a socket already exists on the file system in the ``local_path``, it will be
+    removed first.
+
+    :param remote_path: the path to set as the default target
+    :param local_path: the path on which to bind to
+    :param local_mode: permissions to set on the local socket
+    :return: a connected UNIX datagram socket
+
+    """
+    remote_path = os.fspath(remote_path)
+    raw_socket = await setup_unix_local_socket(
+        local_path, local_mode, socket.SOCK_DGRAM
+    )
+    return await get_async_backend().create_unix_datagram_socket(
+        raw_socket, remote_path
+    )
 
 
 async def getaddrinfo(
-    host: Union[bytearray, bytes, str],
-    port: Union[str, int, None],
+    host: bytes | str | None,
+    port: str | int | None,
     *,
-    family: Union[int, AddressFamily] = 0,
-    type: Union[int, SocketKind] = 0,
+    family: int | AddressFamily = 0,
+    type: int | SocketKind = 0,
     proto: int = 0,
     flags: int = 0,
-) -> GetAddrInfoReturnType:
+) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int]]]:
     """
     Look up a numeric IP address given a host name.
 
-    Internationalized domain names are translated according to the (non-transitional) IDNA 2008
-    standard.
+    Internationalized domain names are translated according to the (non-transitional)
+    IDNA 2008 standard.
 
     .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of
         (host, port), unlike what :func:`socket.getaddrinfo` does.
@@ -479,7 +562,7 @@ async def getaddrinfo(
     # Handle unicode hostnames
     if isinstance(host, str):
         try:
-            encoded_host = host.encode("ascii")
+            encoded_host: bytes | None = host.encode("ascii")
         except UnicodeEncodeError:
             import idna
 
@@ -487,7 +570,7 @@ async def getaddrinfo(
     else:
         encoded_host = host
 
-    gai_res = await get_asynclib().getaddrinfo(
+    gai_res = await get_async_backend().getaddrinfo(
         encoded_host, port, family=family, type=type, proto=proto, flags=flags
     )
     return [
@@ -496,7 +579,7 @@ async def getaddrinfo(
     ]
 
 
-def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[Tuple[str, str]]:
+def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[tuple[str, str]]:
     """
     Look up the host name of an IP address.
 
@@ -507,18 +590,18 @@ def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[Tuple[str
     .. seealso:: :func:`socket.getnameinfo`
 
     """
-    return get_asynclib().getnameinfo(sockaddr, flags)
+    return get_async_backend().getnameinfo(sockaddr, flags)
 
 
 def wait_socket_readable(sock: socket.socket) -> Awaitable[None]:
     """
     Wait until the given socket has data to be read.
 
-    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
-    (default on py3.8+).
+    This does **NOT** work on Windows when using the asyncio backend with a proactor
+    event loop (default on py3.8+).
 
-    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
-        constructs like socket streams!
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher
+        level constructs like socket streams!
 
     :param sock: a socket object
     :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
@@ -527,18 +610,18 @@ def wait_socket_readable(sock: socket.socket) -> Awaitable[None]:
         to become readable
 
     """
-    return get_asynclib().wait_socket_readable(sock)
+    return get_async_backend().wait_socket_readable(sock)
 
 
 def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
     """
     Wait until the given socket can be written to.
 
-    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
-    (default on py3.8+).
+    This does **NOT** work on Windows when using the asyncio backend with a proactor
+    event loop (default on py3.8+).
 
-    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
-        constructs like socket streams!
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher
+        level constructs like socket streams!
 
     :param sock: a socket object
     :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
@@ -547,7 +630,7 @@ def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
         to become writable
 
     """
-    return get_asynclib().wait_socket_writable(sock)
+    return get_async_backend().wait_socket_writable(sock)
 
 
 #
@@ -556,8 +639,8 @@ def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
 
 
 def convert_ipv6_sockaddr(
-    sockaddr: Union[Tuple[str, int, int, int], Tuple[str, int]]
-) -> Tuple[str, int]:
+    sockaddr: tuple[str, int, int, int] | tuple[str, int],
+) -> tuple[str, int]:
     """
     Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format.
 
@@ -571,11 +654,63 @@ def convert_ipv6_sockaddr(
     """
     # This is more complicated than it should be because of MyPy
     if isinstance(sockaddr, tuple) and len(sockaddr) == 4:
-        host, port, flowinfo, scope_id = cast(Tuple[str, int, int, int], sockaddr)
+        host, port, flowinfo, scope_id = sockaddr
         if scope_id:
+            # PyPy (as of v7.3.11) leaves the interface name in the result, so
+            # we discard it and only get the scope ID from the end
+            # (https://foss.heptapod.net/pypy/pypy/-/issues/3938)
+            host = host.split("%")[0]
+
             # Add scope_id to the address
             return f"{host}%{scope_id}", port
         else:
             return host, port
     else:
-        return cast(Tuple[str, int], sockaddr)
+        return sockaddr
+
+
+async def setup_unix_local_socket(
+    path: None | str | bytes | PathLike[Any],
+    mode: int | None,
+    socktype: int,
+) -> socket.socket:
+    """
+    Create a UNIX local socket object, deleting the socket at the given path if it
+    exists.
+
+    Not available on Windows.
+
+    :param path: path of the socket
+    :param mode: permissions to set on the socket
+    :param socktype: socket.SOCK_STREAM or socket.SOCK_DGRAM
+
+    """
+    path_str: str | bytes | None
+    if path is not None:
+        path_str = os.fspath(path)
+
+        # Copied from pathlib...
+        try:
+            stat_result = os.stat(path)
+        except OSError as e:
+            if e.errno not in (errno.ENOENT, errno.ENOTDIR, errno.EBADF, errno.ELOOP):
+                raise
+        else:
+            if stat.S_ISSOCK(stat_result.st_mode):
+                os.unlink(path)
+    else:
+        path_str = None
+
+    raw_socket = socket.socket(socket.AF_UNIX, socktype)
+    raw_socket.setblocking(False)
+
+    if path_str is not None:
+        try:
+            await to_thread.run_sync(raw_socket.bind, path_str, abandon_on_cancel=True)
+            if mode is not None:
+                await to_thread.run_sync(chmod, path_str, mode, abandon_on_cancel=True)
+        except BaseException:
+            raw_socket.close()
+            raise
+
+    return raw_socket
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_streams.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_streams.py
index 188aa8d..aa6b0c2 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_streams.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_streams.py
@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import math
-from typing import Optional, Tuple, Type, TypeVar, overload
+from typing import Tuple, TypeVar
+from warnings import warn
 
 from ..streams.memory import (
     MemoryObjectReceiveStream,
@@ -10,36 +13,40 @@
 T_Item = TypeVar("T_Item")
 
 
-@overload
-def create_memory_object_stream(
-    max_buffer_size: float, item_type: Type[T_Item]
-) -> Tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
-    ...
-
-
-@overload
-def create_memory_object_stream(
-    max_buffer_size: float = 0,
-) -> Tuple[MemoryObjectSendStream, MemoryObjectReceiveStream]:
-    ...
-
-
-def create_memory_object_stream(
-    max_buffer_size: float = 0, item_type: Optional[Type[T_Item]] = None
-) -> Tuple[MemoryObjectSendStream, MemoryObjectReceiveStream]:
+class create_memory_object_stream(
+    Tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]],
+):
     """
     Create a memory object stream.
 
-    :param max_buffer_size: number of items held in the buffer until ``send()`` starts blocking
-    :param item_type: type of item, for marking the streams with the right generic type for
-        static typing (not used at run time)
+    The stream's item type can be annotated like
+    :func:`create_memory_object_stream[T_Item]`.
+
+    :param max_buffer_size: number of items held in the buffer until ``send()`` starts
+        blocking
+    :param item_type: old way of marking the streams with the right generic type for
+        static typing (does nothing on AnyIO 4)
+
+        .. deprecated:: 4.0
+          Use ``create_memory_object_stream[YourItemType](...)`` instead.
     :return: a tuple of (send stream, receive stream)
 
     """
-    if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
-        raise ValueError("max_buffer_size must be either an integer or math.inf")
-    if max_buffer_size < 0:
-        raise ValueError("max_buffer_size cannot be negative")
 
-    state: MemoryObjectStreamState = MemoryObjectStreamState(max_buffer_size)
-    return MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)
+    def __new__(  # type: ignore[misc]
+        cls, max_buffer_size: float = 0, item_type: object = None
+    ) -> tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
+        if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
+            raise ValueError("max_buffer_size must be either an integer or math.inf")
+        if max_buffer_size < 0:
+            raise ValueError("max_buffer_size cannot be negative")
+        if item_type is not None:
+            warn(
+                "The item_type argument has been deprecated in AnyIO 4.0. "
+                "Use create_memory_object_stream[YourItemType](...) instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        state = MemoryObjectStreamState[T_Item](max_buffer_size)
+        return (MemoryObjectSendStream(state), MemoryObjectReceiveStream(state))
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_subprocesses.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_subprocesses.py
index b56f647..5d5d7b7 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_subprocesses.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_subprocesses.py
@@ -1,42 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, Mapping, Sequence
 from io import BytesIO
 from os import PathLike
 from subprocess import DEVNULL, PIPE, CalledProcessError, CompletedProcess
-from typing import AsyncIterable, List, Mapping, Optional, Sequence, Union, cast
+from typing import IO, Any, cast
 
 from ..abc import Process
-from ._eventloop import get_asynclib
+from ._eventloop import get_async_backend
 from ._tasks import create_task_group
 
 
 async def run_process(
-    command: Union[str, Sequence[str]],
+    command: str | bytes | Sequence[str | bytes],
     *,
-    input: Optional[bytes] = None,
-    stdout: int = PIPE,
-    stderr: int = PIPE,
+    input: bytes | None = None,
+    stdout: int | IO[Any] | None = PIPE,
+    stderr: int | IO[Any] | None = PIPE,
     check: bool = True,
-    cwd: Union[str, bytes, PathLike, None] = None,
-    env: Optional[Mapping[str, str]] = None
-) -> CompletedProcess:
+    cwd: str | bytes | PathLike[str] | None = None,
+    env: Mapping[str, str] | None = None,
+    start_new_session: bool = False,
+) -> CompletedProcess[bytes]:
     """
     Run an external command in a subprocess and wait until it completes.
 
     .. seealso:: :func:`subprocess.run`
 
-    :param command: either a string to pass to the shell, or an iterable of strings containing the
-        executable name or path and its arguments
+    :param command: either a string to pass to the shell, or an iterable of strings
+        containing the executable name or path and its arguments
     :param input: bytes passed to the standard input of the subprocess
-    :param stdout: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
-    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL` or
-        :data:`subprocess.STDOUT`
-    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the process
-        terminates with a return code other than 0
-    :param cwd: If not ``None``, change the working directory to this before running the command
-    :param env: if not ``None``, this mapping replaces the inherited environment variables from the
-        parent process
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or `None`
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or `None`
+    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the
+        process terminates with a return code other than 0
+    :param cwd: If not ``None``, change the working directory to this before running the
+        command
+    :param env: if not ``None``, this mapping replaces the inherited environment
+        variables from the parent process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the
+        child process prior to the execution of the subprocess. (POSIX only)
     :return: an object representing the completed process
-    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process exits with a
-        nonzero return code
+    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process
+        exits with a nonzero return code
 
     """
 
@@ -54,22 +62,21 @@ async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
         stderr=stderr,
         cwd=cwd,
         env=env,
+        start_new_session=start_new_session,
     ) as process:
-        stream_contents: List[Optional[bytes]] = [None, None]
-        try:
-            async with create_task_group() as tg:
-                if process.stdout:
-                    tg.start_soon(drain_stream, process.stdout, 0)
-                if process.stderr:
-                    tg.start_soon(drain_stream, process.stderr, 1)
-                if process.stdin and input:
-                    await process.stdin.send(input)
-                    await process.stdin.aclose()
-
-                await process.wait()
-        except BaseException:
-            process.kill()
-            raise
+        stream_contents: list[bytes | None] = [None, None]
+        async with create_task_group() as tg:
+            if process.stdout:
+                tg.start_soon(drain_stream, process.stdout, 0)
+
+            if process.stderr:
+                tg.start_soon(drain_stream, process.stderr, 1)
+
+            if process.stdin and input:
+                await process.stdin.send(input)
+                await process.stdin.aclose()
+
+            await process.wait()
 
     output, errors = stream_contents
     if check and process.returncode != 0:
@@ -79,38 +86,55 @@ async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
 
 
 async def open_process(
-    command: Union[str, Sequence[str]],
+    command: str | bytes | Sequence[str | bytes],
     *,
-    stdin: int = PIPE,
-    stdout: int = PIPE,
-    stderr: int = PIPE,
-    cwd: Union[str, bytes, PathLike, None] = None,
-    env: Optional[Mapping[str, str]] = None
+    stdin: int | IO[Any] | None = PIPE,
+    stdout: int | IO[Any] | None = PIPE,
+    stderr: int | IO[Any] | None = PIPE,
+    cwd: str | bytes | PathLike[str] | None = None,
+    env: Mapping[str, str] | None = None,
+    start_new_session: bool = False,
 ) -> Process:
     """
     Start an external command in a subprocess.
 
     .. seealso:: :class:`subprocess.Popen`
 
-    :param command: either a string to pass to the shell, or an iterable of strings containing the
-        executable name or path and its arguments
-    :param stdin: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
-    :param stdout: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
-    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL` or
-        :data:`subprocess.STDOUT`
+    :param command: either a string to pass to the shell, or an iterable of strings
+        containing the executable name or path and its arguments
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
+        file-like object, or ``None``
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or ``None``
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or ``None``
     :param cwd: If not ``None``, the working directory is changed before executing
-    :param env: If env is not ``None``, it must be a mapping that defines the environment
-        variables for the new process
+    :param env: If env is not ``None``, it must be a mapping that defines the
+        environment variables for the new process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the
+        child process prior to the execution of the subprocess. (POSIX only)
     :return: an asynchronous process object
 
     """
-    shell = isinstance(command, str)
-    return await get_asynclib().open_process(
-        command,
-        shell=shell,
-        stdin=stdin,
-        stdout=stdout,
-        stderr=stderr,
-        cwd=cwd,
-        env=env,
-    )
+    if isinstance(command, (str, bytes)):
+        return await get_async_backend().open_process(
+            command,
+            shell=True,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            cwd=cwd,
+            env=env,
+            start_new_session=start_new_session,
+        )
+    else:
+        return await get_async_backend().open_process(
+            command,
+            shell=False,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+            cwd=cwd,
+            env=env,
+            start_new_session=start_new_session,
+        )
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_synchronization.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_synchronization.py
index cb4f31c..b274a31 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_synchronization.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_synchronization.py
@@ -1,12 +1,14 @@
+from __future__ import annotations
+
+import math
 from collections import deque
 from dataclasses import dataclass
 from types import TracebackType
-from typing import Deque, Optional, Tuple, Type
-from warnings import warn
+
+from sniffio import AsyncLibraryNotFoundError
 
 from ..lowlevel import cancel_shielded_checkpoint, checkpoint, checkpoint_if_cancelled
-from ._compat import DeprecatedAwaitable
-from ._eventloop import get_asynclib
+from ._eventloop import get_async_backend
 from ._exceptions import BusyResourceError, WouldBlock
 from ._tasks import CancelScope
 from ._testing import TaskInfo, get_current_task
@@ -26,15 +28,16 @@ class CapacityLimiterStatistics:
     """
     :ivar int borrowed_tokens: number of tokens currently borrowed by tasks
     :ivar float total_tokens: total number of available tokens
-    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from this
-        limiter
-    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.CapacityLimiter.acquire` or
+    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from
+        this limiter
+    :ivar int tasks_waiting: number of tasks waiting on
+        :meth:`~.CapacityLimiter.acquire` or
         :meth:`~.CapacityLimiter.acquire_on_behalf_of`
     """
 
     borrowed_tokens: int
     total_tokens: float
-    borrowers: Tuple[object, ...]
+    borrowers: tuple[object, ...]
     tasks_waiting: int
 
 
@@ -42,13 +45,13 @@ class CapacityLimiterStatistics:
 class LockStatistics:
     """
     :ivar bool locked: flag indicating if this lock is locked or not
-    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the lock is not
-        held by any task)
+    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the
+        lock is not held by any task)
     :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire`
     """
 
     locked: bool
-    owner: Optional[TaskInfo]
+    owner: TaskInfo | None
     tasks_waiting: int
 
 
@@ -56,7 +59,8 @@ class LockStatistics:
 class ConditionStatistics:
     """
     :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait`
-    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying :class:`~.Lock`
+    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying
+        :class:`~.Lock`
     """
 
     tasks_waiting: int
@@ -74,10 +78,13 @@ class SemaphoreStatistics:
 
 
 class Event:
-    def __new__(cls) -> "Event":
-        return get_asynclib().Event()
+    def __new__(cls) -> Event:
+        try:
+            return get_async_backend().create_event()
+        except AsyncLibraryNotFoundError:
+            return EventAdapter()
 
-    def set(self) -> DeprecatedAwaitable:
+    def set(self) -> None:
         """Set the flag, notifying all listeners."""
         raise NotImplementedError
 
@@ -89,7 +96,8 @@ async def wait(self) -> None:
         """
         Wait until the flag has been set.
 
-        If the flag has already been set when this method is called, it returns immediately.
+        If the flag has already been set when this method is called, it returns
+        immediately.
 
         """
         raise NotImplementedError
@@ -99,20 +107,49 @@ def statistics(self) -> EventStatistics:
         raise NotImplementedError
 
 
+class EventAdapter(Event):
+    _internal_event: Event | None = None
+
+    def __new__(cls) -> EventAdapter:
+        return object.__new__(cls)
+
+    @property
+    def _event(self) -> Event:
+        if self._internal_event is None:
+            self._internal_event = get_async_backend().create_event()
+
+        return self._internal_event
+
+    def set(self) -> None:
+        self._event.set()
+
+    def is_set(self) -> bool:
+        return self._internal_event is not None and self._internal_event.is_set()
+
+    async def wait(self) -> None:
+        await self._event.wait()
+
+    def statistics(self) -> EventStatistics:
+        if self._internal_event is None:
+            return EventStatistics(tasks_waiting=0)
+
+        return self._internal_event.statistics()
+
+
 class Lock:
-    _owner_task: Optional[TaskInfo] = None
+    _owner_task: TaskInfo | None = None
 
     def __init__(self) -> None:
-        self._waiters: Deque[Tuple[TaskInfo, Event]] = deque()
+        self._waiters: deque[tuple[TaskInfo, Event]] = deque()
 
     async def __aenter__(self) -> None:
         await self.acquire()
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.release()
 
@@ -131,18 +168,24 @@ async def acquire(self) -> None:
             except BaseException:
                 if not event.is_set():
                     self._waiters.remove(token)
+                elif self._owner_task == task:
+                    self.release()
 
                 raise
 
             assert self._owner_task == task
         else:
-            await cancel_shielded_checkpoint()
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
 
     def acquire_nowait(self) -> None:
         """
         Acquire the lock, without blocking.
 
-        :raises ~WouldBlock: if the operation would block
+        :raises ~anyio.WouldBlock: if the operation would block
 
         """
         task = get_current_task()
@@ -154,7 +197,7 @@ def acquire_nowait(self) -> None:
 
         self._owner_task = task
 
-    def release(self) -> DeprecatedAwaitable:
+    def release(self) -> None:
         """Release the lock."""
         if self._owner_task != get_current_task():
             raise RuntimeError("The current task is not holding this lock")
@@ -165,8 +208,6 @@ def release(self) -> DeprecatedAwaitable:
         else:
             del self._owner_task
 
-        return DeprecatedAwaitable(self.release)
-
     def locked(self) -> bool:
         """Return True if the lock is currently held."""
         return self._owner_task is not None
@@ -181,20 +222,20 @@ def statistics(self) -> LockStatistics:
 
 
 class Condition:
-    _owner_task: Optional[TaskInfo] = None
+    _owner_task: TaskInfo | None = None
 
-    def __init__(self, lock: Optional[Lock] = None):
+    def __init__(self, lock: Lock | None = None):
         self._lock = lock or Lock()
-        self._waiters: Deque[Event] = deque()
+        self._waiters: deque[Event] = deque()
 
     async def __aenter__(self) -> None:
         await self.acquire()
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.release()
 
@@ -211,16 +252,15 @@ def acquire_nowait(self) -> None:
         """
         Acquire the underlying lock, without blocking.
 
-        :raises ~WouldBlock: if the operation would block
+        :raises ~anyio.WouldBlock: if the operation would block
 
         """
         self._lock.acquire_nowait()
         self._owner_task = get_current_task()
 
-    def release(self) -> DeprecatedAwaitable:
+    def release(self) -> None:
         """Release the underlying lock."""
         self._lock.release()
-        return DeprecatedAwaitable(self.release)
 
     def locked(self) -> bool:
         """Return True if the lock is set."""
@@ -272,7 +312,7 @@ def statistics(self) -> ConditionStatistics:
 
 
 class Semaphore:
-    def __init__(self, initial_value: int, *, max_value: Optional[int] = None):
+    def __init__(self, initial_value: int, *, max_value: int | None = None):
         if not isinstance(initial_value, int):
             raise TypeError("initial_value must be an integer")
         if initial_value < 0:
@@ -287,17 +327,17 @@ def __init__(self, initial_value: int, *, max_value: Optional[int] = None):
 
         self._value = initial_value
         self._max_value = max_value
-        self._waiters: Deque[Event] = deque()
+        self._waiters: deque[Event] = deque()
 
-    async def __aenter__(self) -> "Semaphore":
+    async def __aenter__(self) -> Semaphore:
         await self.acquire()
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.release()
 
@@ -314,16 +354,22 @@ async def acquire(self) -> None:
             except BaseException:
                 if not event.is_set():
                     self._waiters.remove(event)
+                else:
+                    self.release()
 
                 raise
         else:
-            await cancel_shielded_checkpoint()
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
 
     def acquire_nowait(self) -> None:
         """
         Acquire the underlying lock, without blocking.
 
-        :raises ~WouldBlock: if the operation would block
+        :raises ~anyio.WouldBlock: if the operation would block
 
         """
         if self._value == 0:
@@ -331,7 +377,7 @@ def acquire_nowait(self) -> None:
 
         self._value -= 1
 
-    def release(self) -> DeprecatedAwaitable:
+    def release(self) -> None:
         """Increment the semaphore value."""
         if self._max_value is not None and self._value == self._max_value:
             raise ValueError("semaphore released too many times")
@@ -341,15 +387,13 @@ def release(self) -> DeprecatedAwaitable:
         else:
             self._value += 1
 
-        return DeprecatedAwaitable(self.release)
-
     @property
     def value(self) -> int:
         """The current value of the semaphore."""
         return self._value
 
     @property
-    def max_value(self) -> Optional[int]:
+    def max_value(self) -> int | None:
         """The maximum value of the semaphore."""
         return self._max_value
 
@@ -363,18 +407,21 @@ def statistics(self) -> SemaphoreStatistics:
 
 
 class CapacityLimiter:
-    def __new__(cls, total_tokens: float) -> "CapacityLimiter":
-        return get_asynclib().CapacityLimiter(total_tokens)
+    def __new__(cls, total_tokens: float) -> CapacityLimiter:
+        try:
+            return get_async_backend().create_capacity_limiter(total_tokens)
+        except AsyncLibraryNotFoundError:
+            return CapacityLimiterAdapter(total_tokens)
 
     async def __aenter__(self) -> None:
         raise NotImplementedError
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         raise NotImplementedError
 
     @property
@@ -383,7 +430,8 @@ def total_tokens(self) -> float:
         The total number of tokens available for borrowing.
 
         This is a read-write property. If the total number of tokens is increased, the
-        proportionate number of tasks waiting on this limiter will be granted their tokens.
+        proportionate number of tasks waiting on this limiter will be granted their
+        tokens.
 
         .. versionchanged:: 3.0
             The property is now writable.
@@ -395,14 +443,6 @@ def total_tokens(self) -> float:
     def total_tokens(self, value: float) -> None:
         raise NotImplementedError
 
-    async def set_total_tokens(self, value: float) -> None:
-        warn(
-            "CapacityLimiter.set_total_tokens has been deprecated. Set the value of the"
-            '"total_tokens" attribute directly.',
-            DeprecationWarning,
-        )
-        self.total_tokens = value
-
     @property
     def borrowed_tokens(self) -> int:
         """The number of tokens that have currently been borrowed."""
@@ -413,16 +453,17 @@ def available_tokens(self) -> float:
         """The number of tokens currently available to be borrowed"""
         raise NotImplementedError
 
-    def acquire_nowait(self) -> DeprecatedAwaitable:
+    def acquire_nowait(self) -> None:
         """
-        Acquire a token for the current task without waiting for one to become available.
+        Acquire a token for the current task without waiting for one to become
+        available.
 
         :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
 
         """
         raise NotImplementedError
 
-    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
         """
         Acquire a token without waiting for one to become available.
 
@@ -434,7 +475,8 @@ def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
 
     async def acquire(self) -> None:
         """
-        Acquire a token for the current task, waiting if necessary for one to become available.
+        Acquire a token for the current task, waiting if necessary for one to become
+        available.
 
         """
         raise NotImplementedError
@@ -451,7 +493,9 @@ async def acquire_on_behalf_of(self, borrower: object) -> None:
     def release(self) -> None:
         """
         Release the token held by the current task.
-        :raises RuntimeError: if the current task has not borrowed a token from this limiter.
+
+        :raises RuntimeError: if the current task has not borrowed a token from this
+            limiter.
 
         """
         raise NotImplementedError
@@ -460,7 +504,8 @@ def release_on_behalf_of(self, borrower: object) -> None:
         """
         Release the token held by the given borrower.
 
-        :raises RuntimeError: if the borrower has not borrowed a token from this limiter.
+        :raises RuntimeError: if the borrower has not borrowed a token from this
+            limiter.
 
         """
         raise NotImplementedError
@@ -475,96 +520,117 @@ def statistics(self) -> CapacityLimiterStatistics:
         raise NotImplementedError
 
 
-def create_lock() -> Lock:
-    """
-    Create an asynchronous lock.
+class CapacityLimiterAdapter(CapacityLimiter):
+    _internal_limiter: CapacityLimiter | None = None
 
-    :return: a lock object
+    def __new__(cls, total_tokens: float) -> CapacityLimiterAdapter:
+        return object.__new__(cls)
 
-    .. deprecated:: 3.0
-       Use :class:`~Lock` directly.
+    def __init__(self, total_tokens: float) -> None:
+        self.total_tokens = total_tokens
 
-    """
-    warn("create_lock() is deprecated -- use Lock() directly", DeprecationWarning)
-    return Lock()
+    @property
+    def _limiter(self) -> CapacityLimiter:
+        if self._internal_limiter is None:
+            self._internal_limiter = get_async_backend().create_capacity_limiter(
+                self._total_tokens
+            )
 
+        return self._internal_limiter
 
-def create_condition(lock: Optional[Lock] = None) -> Condition:
-    """
-    Create an asynchronous condition.
+    async def __aenter__(self) -> None:
+        await self._limiter.__aenter__()
 
-    :param lock: the lock to base the condition object on
-    :return: a condition object
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        return await self._limiter.__aexit__(exc_type, exc_val, exc_tb)
 
-    .. deprecated:: 3.0
-       Use :class:`~Condition` directly.
+    @property
+    def total_tokens(self) -> float:
+        if self._internal_limiter is None:
+            return self._total_tokens
 
-    """
-    warn(
-        "create_condition() is deprecated -- use Condition() directly",
-        DeprecationWarning,
-    )
-    return Condition(lock=lock)
+        return self._internal_limiter.total_tokens
 
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        if not isinstance(value, int) and value is not math.inf:
+            raise TypeError("total_tokens must be an int or math.inf")
+        elif value < 1:
+            raise ValueError("total_tokens must be >= 1")
 
-def create_event() -> Event:
-    """
-    Create an asynchronous event object.
+        if self._internal_limiter is None:
+            self._total_tokens = value
+            return
 
-    :return: an event object
+        self._limiter.total_tokens = value
 
-    .. deprecated:: 3.0
-       Use :class:`~Event` directly.
+    @property
+    def borrowed_tokens(self) -> int:
+        if self._internal_limiter is None:
+            return 0
 
-    """
-    warn("create_event() is deprecated -- use Event() directly", DeprecationWarning)
-    return get_asynclib().Event()
+        return self._internal_limiter.borrowed_tokens
 
+    @property
+    def available_tokens(self) -> float:
+        if self._internal_limiter is None:
+            return self._total_tokens
 
-def create_semaphore(value: int, *, max_value: Optional[int] = None) -> Semaphore:
-    """
-    Create an asynchronous semaphore.
+        return self._internal_limiter.available_tokens
 
-    :param value: the semaphore's initial value
-    :param max_value: if set, makes this a "bounded" semaphore that raises :exc:`ValueError` if the
-        semaphore's value would exceed this number
-    :return: a semaphore object
+    def acquire_nowait(self) -> None:
+        self._limiter.acquire_nowait()
 
-    .. deprecated:: 3.0
-       Use :class:`~Semaphore` directly.
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        self._limiter.acquire_on_behalf_of_nowait(borrower)
 
-    """
-    warn(
-        "create_semaphore() is deprecated -- use Semaphore() directly",
-        DeprecationWarning,
-    )
-    return Semaphore(value, max_value=max_value)
+    async def acquire(self) -> None:
+        await self._limiter.acquire()
 
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self._limiter.acquire_on_behalf_of(borrower)
 
-def create_capacity_limiter(total_tokens: float) -> CapacityLimiter:
-    """
-    Create a capacity limiter.
+    def release(self) -> None:
+        self._limiter.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        self._limiter.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        if self._internal_limiter is None:
+            return CapacityLimiterStatistics(
+                borrowed_tokens=0,
+                total_tokens=self.total_tokens,
+                borrowers=(),
+                tasks_waiting=0,
+            )
 
-    :param total_tokens: the total number of tokens available for borrowing (can be an integer or
-        :data:`math.inf`)
-    :return: a capacity limiter object
+        return self._internal_limiter.statistics()
 
-    .. deprecated:: 3.0
-       Use :class:`~CapacityLimiter` directly.
 
+class ResourceGuard:
     """
-    warn(
-        "create_capacity_limiter() is deprecated -- use CapacityLimiter() directly",
-        DeprecationWarning,
-    )
-    return get_asynclib().CapacityLimiter(total_tokens)
+    A context manager for ensuring that a resource is only used by a single task at a
+    time.
 
+    Entering this context manager while the previous has not exited it yet will trigger
+    :exc:`BusyResourceError`.
+
+    :param action: the action to guard against (visible in the :exc:`BusyResourceError`
+        when triggered, e.g. "Another task is already {action} this resource")
+
+    .. versionadded:: 4.1
+    """
 
-class ResourceGuard:
     __slots__ = "action", "_guarded"
 
-    def __init__(self, action: str):
-        self.action = action
+    def __init__(self, action: str = "using"):
+        self.action: str = action
         self._guarded = False
 
     def __enter__(self) -> None:
@@ -575,9 +641,9 @@ def __enter__(self) -> None:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         self._guarded = False
         return None
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_tasks.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_tasks.py
index f0e5dd7..2f21ea2 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_tasks.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_tasks.py
@@ -1,18 +1,15 @@
+from __future__ import annotations
+
 import math
+from collections.abc import Generator
+from contextlib import contextmanager
 from types import TracebackType
-from typing import Optional, Type
-from warnings import warn
 
 from ..abc._tasks import TaskGroup, TaskStatus
-from ._compat import (
-    DeprecatedAsyncContextManager,
-    DeprecatedAwaitable,
-    DeprecatedAwaitableFloat,
-)
-from ._eventloop import get_asynclib
+from ._eventloop import get_async_backend
 
 
-class _IgnoredTaskStatus(TaskStatus):
+class _IgnoredTaskStatus(TaskStatus[object]):
     def started(self, value: object = None) -> None:
         pass
 
@@ -20,7 +17,7 @@ def started(self, value: object = None) -> None:
 TASK_STATUS_IGNORED = _IgnoredTaskStatus()
 
 
-class CancelScope(DeprecatedAsyncContextManager["CancelScope"]):
+class CancelScope:
     """
     Wraps a unit of work that can be made separately cancellable.
 
@@ -30,10 +27,10 @@ class CancelScope(DeprecatedAsyncContextManager["CancelScope"]):
 
     def __new__(
         cls, *, deadline: float = math.inf, shield: bool = False
-    ) -> "CancelScope":
-        return get_asynclib().CancelScope(shield=shield, deadline=deadline)
+    ) -> CancelScope:
+        return get_async_backend().create_cancel_scope(shield=shield, deadline=deadline)
 
-    def cancel(self) -> DeprecatedAwaitable:
+    def cancel(self) -> None:
         """Cancel this scope immediately."""
         raise NotImplementedError
 
@@ -56,6 +53,19 @@ def cancel_called(self) -> bool:
         """``True`` if :meth:`cancel` has been called."""
         raise NotImplementedError
 
+    @property
+    def cancelled_caught(self) -> bool:
+        """
+        ``True`` if this scope suppressed a cancellation exception it itself raised.
+
+        This is typically used to check if any work was interrupted, or to see if the
+        scope was cancelled due to its deadline being reached. The value will, however,
+        only be ``True`` if the cancellation was triggered by the scope itself (and not
+        an outer scope).
+
+        """
+        raise NotImplementedError
+
     @property
     def shield(self) -> bool:
         """
@@ -70,109 +80,79 @@ def shield(self) -> bool:
     def shield(self, value: bool) -> None:
         raise NotImplementedError
 
-    def __enter__(self) -> "CancelScope":
+    def __enter__(self) -> CancelScope:
         raise NotImplementedError
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         raise NotImplementedError
 
 
-def open_cancel_scope(*, shield: bool = False) -> CancelScope:
+@contextmanager
+def fail_after(
+    delay: float | None, shield: bool = False
+) -> Generator[CancelScope, None, None]:
     """
-    Open a cancel scope.
+    Create a context manager which raises a :class:`TimeoutError` if does not finish in
+    time.
 
-    :param shield: ``True`` to shield the cancel scope from external cancellation
-    :return: a cancel scope
-
-    .. deprecated:: 3.0
-       Use :class:`~CancelScope` directly.
-
-    """
-    warn(
-        "open_cancel_scope() is deprecated -- use CancelScope() directly",
-        DeprecationWarning,
-    )
-    return get_asynclib().CancelScope(shield=shield)
-
-
-class FailAfterContextManager(DeprecatedAsyncContextManager):
-    def __init__(self, cancel_scope: CancelScope):
-        self._cancel_scope = cancel_scope
-
-    def __enter__(self) -> CancelScope:
-        return self._cancel_scope.__enter__()
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
-        retval = self._cancel_scope.__exit__(exc_type, exc_val, exc_tb)
-        if self._cancel_scope.cancel_called:
-            raise TimeoutError
-
-        return retval
-
-
-def fail_after(delay: Optional[float], shield: bool = False) -> FailAfterContextManager:
-    """
-    Create a context manager which raises a :class:`TimeoutError` if does not finish in time.
-
-    :param delay: maximum allowed time (in seconds) before raising the exception, or ``None`` to
-        disable the timeout
+    :param delay: maximum allowed time (in seconds) before raising the exception, or
+        ``None`` to disable the timeout
     :param shield: ``True`` to shield the cancel scope from external cancellation
     :return: a context manager that yields a cancel scope
-    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.abc.CancelScope`\\]
+    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\]
 
     """
-    deadline = (
-        (get_asynclib().current_time() + delay) if delay is not None else math.inf
-    )
-    cancel_scope = get_asynclib().CancelScope(deadline=deadline, shield=shield)
-    return FailAfterContextManager(cancel_scope)
+    current_time = get_async_backend().current_time
+    deadline = (current_time() + delay) if delay is not None else math.inf
+    with get_async_backend().create_cancel_scope(
+        deadline=deadline, shield=shield
+    ) as cancel_scope:
+        yield cancel_scope
+
+    if cancel_scope.cancelled_caught and current_time() >= cancel_scope.deadline:
+        raise TimeoutError
 
 
-def move_on_after(delay: Optional[float], shield: bool = False) -> CancelScope:
+def move_on_after(delay: float | None, shield: bool = False) -> CancelScope:
     """
     Create a cancel scope with a deadline that expires after the given delay.
 
-    :param delay: maximum allowed time (in seconds) before exiting the context block, or ``None``
-        to disable the timeout
+    :param delay: maximum allowed time (in seconds) before exiting the context block, or
+        ``None`` to disable the timeout
     :param shield: ``True`` to shield the cancel scope from external cancellation
     :return: a cancel scope
 
     """
     deadline = (
-        (get_asynclib().current_time() + delay) if delay is not None else math.inf
+        (get_async_backend().current_time() + delay) if delay is not None else math.inf
     )
-    return get_asynclib().CancelScope(deadline=deadline, shield=shield)
+    return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield)
 
 
-def current_effective_deadline() -> DeprecatedAwaitableFloat:
+def current_effective_deadline() -> float:
     """
-    Return the nearest deadline among all the cancel scopes effective for the current task.
+    Return the nearest deadline among all the cancel scopes effective for the current
+    task.
 
-    :return: a clock value from the event loop's internal clock (``float('inf')`` if there is no
-        deadline in effect)
+    :return: a clock value from the event loop's internal clock (or ``float('inf')`` if
+        there is no deadline in effect, or ``float('-inf')`` if the current scope has
+        been cancelled)
     :rtype: float
 
     """
-    return DeprecatedAwaitableFloat(
-        get_asynclib().current_effective_deadline(), current_effective_deadline
-    )
+    return get_async_backend().current_effective_deadline()
 
 
-def create_task_group() -> "TaskGroup":
+def create_task_group() -> TaskGroup:
     """
     Create a task group.
 
     :return: a task group
 
     """
-    return get_asynclib().TaskGroup()
+    return get_async_backend().create_task_group()
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_testing.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_testing.py
index d0c9002..1dae3b1 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_testing.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_testing.py
@@ -1,7 +1,9 @@
-from typing import Coroutine, Generator, Optional
+from __future__ import annotations
 
-from ._compat import DeprecatedAwaitableList, _warn_deprecation
-from ._eventloop import get_asynclib
+from collections.abc import Awaitable, Generator
+from typing import Any
+
+from ._eventloop import get_async_backend
 
 
 class TaskInfo:
@@ -18,14 +20,18 @@ class TaskInfo:
     __slots__ = "_name", "id", "parent_id", "name", "coro"
 
     def __init__(
-        self, id: int, parent_id: Optional[int], name: Optional[str], coro: Coroutine
+        self,
+        id: int,
+        parent_id: int | None,
+        name: str | None,
+        coro: Generator[Any, Any, Any] | Awaitable[Any],
     ):
         func = get_current_task
         self._name = f"{func.__module__}.{func.__qualname__}"
-        self.id = id
-        self.parent_id = parent_id
-        self.name = name
-        self.coro = coro
+        self.id: int = id
+        self.parent_id: int | None = parent_id
+        self.name: str | None = name
+        self.coro: Generator[Any, Any, Any] | Awaitable[Any] = coro
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, TaskInfo):
@@ -39,14 +45,7 @@ def __hash__(self) -> int:
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
 
-    def __await__(self) -> Generator[None, None, "TaskInfo"]:
-        _warn_deprecation(self)
-        if False:
-            yield
-
-        return self
-
-    def _unwrap(self) -> "TaskInfo":
+    def _unwrap(self) -> TaskInfo:
         return self
 
 
@@ -57,20 +56,19 @@ def get_current_task() -> TaskInfo:
     :return: a representation of the current task
 
     """
-    return get_asynclib().get_current_task()
+    return get_async_backend().get_current_task()
 
 
-def get_running_tasks() -> DeprecatedAwaitableList[TaskInfo]:
+def get_running_tasks() -> list[TaskInfo]:
     """
     Return a list of running tasks in the current event loop.
 
     :return: a list of task info objects
 
     """
-    tasks = get_asynclib().get_running_tasks()
-    return DeprecatedAwaitableList(tasks, func=get_running_tasks)
+    return get_async_backend().get_running_tasks()
 
 
 async def wait_all_tasks_blocked() -> None:
     """Wait until all other tasks are waiting for something."""
-    await get_asynclib().wait_all_tasks_blocked()
+    await get_async_backend().wait_all_tasks_blocked()
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/_core/_typedattr.py b/addon/globalPlugins/spellcheck/libs/anyio/_core/_typedattr.py
index 424836a..74c6b8f 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/_core/_typedattr.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/_core/_typedattr.py
@@ -1,12 +1,9 @@
-import sys
-from typing import Any, Callable, Dict, Mapping, TypeVar, Union, overload
+from __future__ import annotations
 
-from ._exceptions import TypedAttributeLookupError
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar, final, overload
 
-if sys.version_info >= (3, 8):
-    from typing import final
-else:
-    from typing_extensions import final
+from ._exceptions import TypedAttributeLookupError
 
 T_Attr = TypeVar("T_Attr")
 T_Default = TypeVar("T_Default")
@@ -26,7 +23,7 @@ class TypedAttributeSet:
     """
 
     def __init_subclass__(cls) -> None:
-        annotations: Dict[str, Any] = getattr(cls, "__annotations__", {})
+        annotations: dict[str, Any] = getattr(cls, "__annotations__", {})
         for attrname in dir(cls):
             if not attrname.startswith("_") and attrname not in annotations:
                 raise TypeError(
@@ -42,11 +39,12 @@ class TypedAttributeProvider:
     @property
     def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
         """
-        A mapping of the extra attributes to callables that return the corresponding values.
+        A mapping of the extra attributes to callables that return the corresponding
+        values.
 
-        If the provider wraps another provider, the attributes from that wrapper should also be
-        included in the returned mapping (but the wrapper may override the callables from the
-        wrapped instance).
+        If the provider wraps another provider, the attributes from that wrapper should
+        also be included in the returned mapping (but the wrapper may override the
+        callables from the wrapped instance).
 
         """
         return {}
@@ -56,7 +54,7 @@ def extra(self, attribute: T_Attr) -> T_Attr:
         ...
 
     @overload
-    def extra(self, attribute: T_Attr, default: T_Default) -> Union[T_Attr, T_Default]:
+    def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default:
         ...
 
     @final
@@ -66,10 +64,12 @@ def extra(self, attribute: Any, default: object = undefined) -> object:
 
         Return the value of the given typed extra attribute.
 
-        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to look for
-        :param default: the value that should be returned if no value is found for the attribute
-        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default value was
-            given
+        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to
+            look for
+        :param default: the value that should be returned if no value is found for the
+            attribute
+        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default
+            value was given
 
         """
         try:
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/__init__.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/__init__.py
index 99ea066..1ca0fcf 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/__init__.py
@@ -1,84 +1,57 @@
-__all__ = (
-    "AsyncResource",
-    "IPAddressType",
-    "IPSockAddrType",
-    "SocketAttribute",
-    "SocketStream",
-    "SocketListener",
-    "UDPSocket",
-    "UNIXSocketStream",
-    "UDPPacketType",
-    "ConnectedUDPSocket",
-    "UnreliableObjectReceiveStream",
-    "UnreliableObjectSendStream",
-    "UnreliableObjectStream",
-    "ObjectReceiveStream",
-    "ObjectSendStream",
-    "ObjectStream",
-    "ByteReceiveStream",
-    "ByteSendStream",
-    "ByteStream",
-    "AnyUnreliableByteReceiveStream",
-    "AnyUnreliableByteSendStream",
-    "AnyUnreliableByteStream",
-    "AnyByteReceiveStream",
-    "AnyByteSendStream",
-    "AnyByteStream",
-    "Listener",
-    "Process",
-    "Event",
-    "Condition",
-    "Lock",
-    "Semaphore",
-    "CapacityLimiter",
-    "CancelScope",
-    "TaskGroup",
-    "TaskStatus",
-    "TestRunner",
-    "BlockingPortal",
-)
+from __future__ import annotations
 
-from ._resources import AsyncResource
-from ._sockets import (
-    ConnectedUDPSocket,
-    IPAddressType,
-    IPSockAddrType,
-    SocketAttribute,
-    SocketListener,
-    SocketStream,
-    UDPPacketType,
-    UDPSocket,
-    UNIXSocketStream,
-)
-from ._streams import (
-    AnyByteReceiveStream,
-    AnyByteSendStream,
-    AnyByteStream,
-    AnyUnreliableByteReceiveStream,
-    AnyUnreliableByteSendStream,
-    AnyUnreliableByteStream,
-    ByteReceiveStream,
-    ByteSendStream,
-    ByteStream,
-    Listener,
-    ObjectReceiveStream,
-    ObjectSendStream,
-    ObjectStream,
-    UnreliableObjectReceiveStream,
-    UnreliableObjectSendStream,
-    UnreliableObjectStream,
-)
-from ._subprocesses import Process
-from ._tasks import TaskGroup, TaskStatus
-from ._testing import TestRunner
+from typing import Any
+
+from ._eventloop import AsyncBackend as AsyncBackend
+from ._resources import AsyncResource as AsyncResource
+from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket
+from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket
+from ._sockets import IPAddressType as IPAddressType
+from ._sockets import IPSockAddrType as IPSockAddrType
+from ._sockets import SocketAttribute as SocketAttribute
+from ._sockets import SocketListener as SocketListener
+from ._sockets import SocketStream as SocketStream
+from ._sockets import UDPPacketType as UDPPacketType
+from ._sockets import UDPSocket as UDPSocket
+from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType
+from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket
+from ._sockets import UNIXSocketStream as UNIXSocketStream
+from ._streams import AnyByteReceiveStream as AnyByteReceiveStream
+from ._streams import AnyByteSendStream as AnyByteSendStream
+from ._streams import AnyByteStream as AnyByteStream
+from ._streams import AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream
+from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream
+from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream
+from ._streams import ByteReceiveStream as ByteReceiveStream
+from ._streams import ByteSendStream as ByteSendStream
+from ._streams import ByteStream as ByteStream
+from ._streams import Listener as Listener
+from ._streams import ObjectReceiveStream as ObjectReceiveStream
+from ._streams import ObjectSendStream as ObjectSendStream
+from ._streams import ObjectStream as ObjectStream
+from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream
+from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream
+from ._streams import UnreliableObjectStream as UnreliableObjectStream
+from ._subprocesses import Process as Process
+from ._tasks import TaskGroup as TaskGroup
+from ._tasks import TaskStatus as TaskStatus
+from ._testing import TestRunner as TestRunner
 
 # Re-exported here, for backwards compatibility
 # isort: off
-from .._core._synchronization import CapacityLimiter, Condition, Event, Lock, Semaphore
-from .._core._tasks import CancelScope
-from ..from_thread import BlockingPortal
+from .._core._synchronization import (
+    CapacityLimiter as CapacityLimiter,
+    Condition as Condition,
+    Event as Event,
+    Lock as Lock,
+    Semaphore as Semaphore,
+)
+from .._core._tasks import CancelScope as CancelScope
+from ..from_thread import BlockingPortal as BlockingPortal
 
 # Re-export imports so they look like they live directly in this package
+key: str
+value: Any
 for key, value in list(locals().items()):
     if getattr(value, "__module__", "").startswith("anyio.abc."):
         value.__module__ = __name__
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_eventloop.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_eventloop.py
new file mode 100644
index 0000000..4470d83
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_eventloop.py
@@ -0,0 +1,392 @@
+from __future__ import annotations
+
+import math
+import sys
+from abc import ABCMeta, abstractmethod
+from collections.abc import AsyncIterator, Awaitable, Mapping
+from os import PathLike
+from signal import Signals
+from socket import AddressFamily, SocketKind, socket
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ContextManager,
+    Sequence,
+    TypeVar,
+    overload,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    from .._core._synchronization import CapacityLimiter, Event
+    from .._core._tasks import CancelScope
+    from .._core._testing import TaskInfo
+    from ..from_thread import BlockingPortal
+    from ._sockets import (
+        ConnectedUDPSocket,
+        ConnectedUNIXDatagramSocket,
+        IPSockAddrType,
+        SocketListener,
+        SocketStream,
+        UDPSocket,
+        UNIXDatagramSocket,
+        UNIXSocketStream,
+    )
+    from ._subprocesses import Process
+    from ._tasks import TaskGroup
+    from ._testing import TestRunner
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+class AsyncBackend(metaclass=ABCMeta):
+    @classmethod
+    @abstractmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        """
+        Run the given coroutine function in an asynchronous event loop.
+
+        The current thread must not be already running an event loop.
+
+        :param func: a coroutine function
+        :param args: positional arguments to ``func``
+        :param kwargs: positional arguments to ``func``
+        :param options: keyword arguments to call the backend ``run()`` implementation
+            with
+        :return: the return value of the coroutine function
+        """
+
+    @classmethod
+    @abstractmethod
+    def current_token(cls) -> object:
+        """
+
+        :return:
+        """
+
+    @classmethod
+    @abstractmethod
+    def current_time(cls) -> float:
+        """
+        Return the current value of the event loop's internal clock.
+
+        :return: the clock value (seconds)
+        """
+
+    @classmethod
+    @abstractmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        """Return the exception class that is raised in a task if it's cancelled."""
+
+    @classmethod
+    @abstractmethod
+    async def checkpoint(cls) -> None:
+        """
+        Check if the task has been cancelled, and allow rescheduling of other tasks.
+
+        This is effectively the same as running :meth:`checkpoint_if_cancelled` and then
+        :meth:`cancel_shielded_checkpoint`.
+        """
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        """
+        Check if the current task group has been cancelled.
+
+        This will check if the task has been cancelled, but will not allow other tasks
+        to be scheduled if not.
+
+        """
+        if cls.current_effective_deadline() == -math.inf:
+            await cls.checkpoint()
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        """
+        Allow the rescheduling of other tasks.
+
+        This will give other tasks the opportunity to run, but without checking if the
+        current task group has been cancelled, unlike with :meth:`checkpoint`.
+
+        """
+        with cls.create_cancel_scope(shield=True):
+            await cls.sleep(0)
+
+    @classmethod
+    @abstractmethod
+    async def sleep(cls, delay: float) -> None:
+        """
+        Pause the current task for the specified duration.
+
+        :param delay: the duration, in seconds
+        """
+
+    @classmethod
+    @abstractmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> CancelScope:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def current_effective_deadline(cls) -> float:
+        """
+        Return the nearest deadline among all the cancel scopes effective for the
+        current task.
+
+        :return:
+            - a clock value from the event loop's internal clock
+            - ``inf`` if there is no deadline in effect
+            - ``-inf`` if the current scope has been cancelled
+        :rtype: float
+        """
+
+    @classmethod
+    @abstractmethod
+    def create_task_group(cls) -> TaskGroup:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_event(cls) -> Event:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: CapacityLimiter | None = None,
+    ) -> T_Retval:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def check_cancelled(cls) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_blocking_portal(cls) -> BlockingPortal:
+        pass
+
+    @classmethod
+    @overload
+    async def open_process(
+        cls,
+        command: str | bytes,
+        *,
+        shell: Literal[True],
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: str | bytes | PathLike[str] | None = None,
+        env: Mapping[str, str] | None = None,
+        start_new_session: bool = False,
+    ) -> Process:
+        pass
+
+    @classmethod
+    @overload
+    async def open_process(
+        cls,
+        command: Sequence[str | bytes],
+        *,
+        shell: Literal[False],
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: str | bytes | PathLike[str] | None = None,
+        env: Mapping[str, str] | None = None,
+        start_new_session: bool = False,
+    ) -> Process:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def open_process(
+        cls,
+        command: str | bytes | Sequence[str | bytes],
+        *,
+        shell: bool,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: str | bytes | PathLike[str] | None = None,
+        env: Mapping[str, str] | None = None,
+        start_new_session: bool = False,
+    ) -> Process:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[Process]) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> SocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def connect_unix(cls, path: str | bytes) -> UNIXSocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_tcp_listener(cls, sock: socket) -> SocketListener:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_unix_listener(cls, sock: socket) -> SocketListener:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def create_udp_socket(
+        cls,
+        family: AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        pass
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: None
+    ) -> UNIXDatagramSocket:
+        ...
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: str | bytes
+    ) -> ConnectedUNIXDatagramSocket:
+        ...
+
+    @classmethod
+    @abstractmethod
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: str | bytes | None
+    ) -> UNIXDatagramSocket | ConnectedUNIXDatagramSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> list[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int],
+        ]
+    ]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_socket_readable(cls, sock: socket) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_socket_writable(cls, sock: socket) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> ContextManager[AsyncIterator[Signals]]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_current_task(cls) -> TaskInfo:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_running_tasks(cls) -> list[TaskInfo]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        pass
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_resources.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_resources.py
index 4f66c38..9693835 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_resources.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_resources.py
@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from abc import ABCMeta, abstractmethod
 from types import TracebackType
-from typing import Optional, Type, TypeVar
+from typing import TypeVar
 
 T = TypeVar("T")
 
@@ -9,8 +11,8 @@ class AsyncResource(metaclass=ABCMeta):
     """
     Abstract base class for all closeable asynchronous resources.
 
-    Works as an asynchronous context manager which returns the instance itself on enter, and calls
-    :meth:`aclose` on exit.
+    Works as an asynchronous context manager which returns the instance itself on enter,
+    and calls :meth:`aclose` on exit.
     """
 
     async def __aenter__(self: T) -> T:
@@ -18,9 +20,9 @@ async def __aenter__(self: T) -> T:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         await self.aclose()
 
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_sockets.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_sockets.py
index f73e795..b321225 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_sockets.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_sockets.py
@@ -1,36 +1,28 @@
+from __future__ import annotations
+
 import socket
 from abc import abstractmethod
+from collections.abc import Callable, Collection, Mapping
+from contextlib import AsyncExitStack
 from io import IOBase
 from ipaddress import IPv4Address, IPv6Address
 from socket import AddressFamily
 from types import TracebackType
-from typing import (
-    Any,
-    AsyncContextManager,
-    Callable,
-    Collection,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Any, Tuple, TypeVar, Union
 
 from .._core._typedattr import (
     TypedAttributeProvider,
     TypedAttributeSet,
     typed_attribute,
 )
-from ._streams import ByteStream, Listener, T_Stream, UnreliableObjectStream
+from ._streams import ByteStream, Listener, UnreliableObjectStream
 from ._tasks import TaskGroup
 
 IPAddressType = Union[str, IPv4Address, IPv6Address]
 IPSockAddrType = Tuple[str, int]
 SockAddrType = Union[IPSockAddrType, str]
 UDPPacketType = Tuple[bytes, IPSockAddrType]
+UNIXDatagramPacketType = Tuple[bytes, str]
 T_Retval = TypeVar("T_Retval")
 
 
@@ -40,10 +32,10 @@ async def __aenter__(self) -> None:
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         return None
 
 
@@ -67,7 +59,7 @@ class _SocketProvider(TypedAttributeProvider):
     def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
         from .._core._sockets import convert_ipv6_sockaddr as convert
 
-        attributes: Dict[Any, Callable[[], Any]] = {
+        attributes: dict[Any, Callable[[], Any]] = {
             SocketAttribute.family: lambda: self._raw_socket.family,
             SocketAttribute.local_address: lambda: convert(
                 self._raw_socket.getsockname()
@@ -75,9 +67,7 @@ def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
             SocketAttribute.raw_socket: lambda: self._raw_socket,
         }
         try:
-            peername: Optional[Tuple[str, int]] = convert(
-                self._raw_socket.getpeername()
-            )
+            peername: tuple[str, int] | None = convert(self._raw_socket.getpeername())
         except OSError:
             peername = None
 
@@ -87,9 +77,9 @@ def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
 
         # Provide local and remote ports for IP based sockets
         if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6):
-            attributes[
-                SocketAttribute.local_port
-            ] = lambda: self._raw_socket.getsockname()[1]
+            attributes[SocketAttribute.local_port] = (
+                lambda: self._raw_socket.getsockname()[1]
+            )
             if peername is not None:
                 remote_port = peername[1]
                 attributes[SocketAttribute.remote_port] = lambda: remote_port
@@ -112,19 +102,17 @@ class SocketStream(ByteStream, _SocketProvider):
 
 class UNIXSocketStream(SocketStream):
     @abstractmethod
-    async def send_fds(
-        self, message: bytes, fds: Collection[Union[int, IOBase]]
-    ) -> None:
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
         """
         Send file descriptors along with a message to the peer.
 
         :param message: a non-empty bytestring
-        :param fds: a collection of files (either numeric file descriptors or open file or socket
-            objects)
+        :param fds: a collection of files (either numeric file descriptors or open file
+            or socket objects)
         """
 
     @abstractmethod
-    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
         """
         Receive file descriptors along with a message from the peer.
 
@@ -146,18 +134,16 @@ async def accept(self) -> SocketStream:
         """Accept an incoming connection."""
 
     async def serve(
-        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+        self,
+        handler: Callable[[SocketStream], Any],
+        task_group: TaskGroup | None = None,
     ) -> None:
         from .. import create_task_group
 
-        context_manager: AsyncContextManager
-        if task_group is None:
-            task_group = context_manager = create_task_group()
-        else:
-            # Can be replaced with AsyncExitStack once on py3.7+
-            context_manager = _NullAsyncContextManager()
+        async with AsyncExitStack() as stack:
+            if task_group is None:
+                task_group = await stack.enter_async_context(create_task_group())
 
-        async with context_manager:
             while True:
                 stream = await self.accept()
                 task_group.start_soon(handler, stream)
@@ -171,7 +157,10 @@ class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider):
     """
 
     async def sendto(self, data: bytes, host: str, port: int) -> None:
-        """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port)))."""
+        """
+        Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port))).
+
+        """
         return await self.send((data, (host, port)))
 
 
@@ -181,3 +170,25 @@ class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider):
 
     Supports all relevant extra attributes from :class:`~SocketAttribute`.
     """
+
+
+class UNIXDatagramSocket(
+    UnreliableObjectStream[UNIXDatagramPacketType], _SocketProvider
+):
+    """
+    Represents an unconnected Unix datagram socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    async def sendto(self, data: bytes, path: str) -> None:
+        """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, path))."""
+        return await self.send((data, path))
+
+
+class ConnectedUNIXDatagramSocket(UnreliableObjectStream[bytes], _SocketProvider):
+    """
+    Represents a connected Unix datagram socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_streams.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_streams.py
index 4980ef4..8c63868 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_streams.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_streams.py
@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 from abc import abstractmethod
-from typing import Any, Callable, Generic, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar, Union
 
 from .._core._exceptions import EndOfStream
 from .._core._typedattr import TypedAttributeProvider
@@ -7,33 +10,34 @@
 from ._tasks import TaskGroup
 
 T_Item = TypeVar("T_Item")
-T_Stream = TypeVar("T_Stream")
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
 
 
 class UnreliableObjectReceiveStream(
-    Generic[T_Item], AsyncResource, TypedAttributeProvider
+    Generic[T_co], AsyncResource, TypedAttributeProvider
 ):
     """
     An interface for receiving objects.
 
-    This interface makes no guarantees that the received messages arrive in the order in which they
-    were sent, or that no messages are missed.
+    This interface makes no guarantees that the received messages arrive in the order in
+    which they were sent, or that no messages are missed.
 
-    Asynchronously iterating over objects of this type will yield objects matching the given type
-    parameter.
+    Asynchronously iterating over objects of this type will yield objects matching the
+    given type parameter.
     """
 
-    def __aiter__(self) -> "UnreliableObjectReceiveStream[T_Item]":
+    def __aiter__(self) -> UnreliableObjectReceiveStream[T_co]:
         return self
 
-    async def __anext__(self) -> T_Item:
+    async def __anext__(self) -> T_co:
         try:
             return await self.receive()
         except EndOfStream:
             raise StopAsyncIteration
 
     @abstractmethod
-    async def receive(self) -> T_Item:
+    async def receive(self) -> T_co:
         """
         Receive the next item.
 
@@ -46,17 +50,17 @@ async def receive(self) -> T_Item:
 
 
 class UnreliableObjectSendStream(
-    Generic[T_Item], AsyncResource, TypedAttributeProvider
+    Generic[T_contra], AsyncResource, TypedAttributeProvider
 ):
     """
     An interface for sending objects.
 
-    This interface makes no guarantees that the messages sent will reach the recipient(s) in the
-    same order in which they were sent, or at all.
+    This interface makes no guarantees that the messages sent will reach the
+    recipient(s) in the same order in which they were sent, or at all.
     """
 
     @abstractmethod
-    async def send(self, item: T_Item) -> None:
+    async def send(self, item: T_contra) -> None:
         """
         Send an item to the peer(s).
 
@@ -72,22 +76,22 @@ class UnreliableObjectStream(
     UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item]
 ):
     """
-    A bidirectional message stream which does not guarantee the order or reliability of message
-    delivery.
+    A bidirectional message stream which does not guarantee the order or reliability of
+    message delivery.
     """
 
 
-class ObjectReceiveStream(UnreliableObjectReceiveStream[T_Item]):
+class ObjectReceiveStream(UnreliableObjectReceiveStream[T_co]):
     """
-    A receive message stream which guarantees that messages are received in the same order in
-    which they were sent, and that no messages are missed.
+    A receive message stream which guarantees that messages are received in the same
+    order in which they were sent, and that no messages are missed.
     """
 
 
-class ObjectSendStream(UnreliableObjectSendStream[T_Item]):
+class ObjectSendStream(UnreliableObjectSendStream[T_contra]):
     """
-    A send message stream which guarantees that messages are delivered in the same order in which
-    they were sent, without missing any messages in the middle.
+    A send message stream which guarantees that messages are delivered in the same order
+    in which they were sent, without missing any messages in the middle.
     """
 
 
@@ -97,7 +101,8 @@ class ObjectStream(
     UnreliableObjectStream[T_Item],
 ):
     """
-    A bidirectional message stream which guarantees the order and reliability of message delivery.
+    A bidirectional message stream which guarantees the order and reliability of message
+    delivery.
     """
 
     @abstractmethod
@@ -105,8 +110,8 @@ async def send_eof(self) -> None:
         """
         Send an end-of-file indication to the peer.
 
-        You should not try to send any further data to this stream after calling this method.
-        This method is idempotent (does nothing on successive calls).
+        You should not try to send any further data to this stream after calling this
+        method. This method is idempotent (does nothing on successive calls).
         """
 
 
@@ -114,11 +119,11 @@ class ByteReceiveStream(AsyncResource, TypedAttributeProvider):
     """
     An interface for receiving bytes from a single peer.
 
-    Iterating this byte stream will yield a byte string of arbitrary length, but no more than
-    65536 bytes.
+    Iterating this byte stream will yield a byte string of arbitrary length, but no more
+    than 65536 bytes.
     """
 
-    def __aiter__(self) -> "ByteReceiveStream":
+    def __aiter__(self) -> ByteReceiveStream:
         return self
 
     async def __anext__(self) -> bytes:
@@ -132,8 +137,8 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
         """
         Receive at most ``max_bytes`` bytes from the peer.
 
-        .. note:: Implementors of this interface should not return an empty :class:`bytes` object,
-            and users should ignore them.
+        .. note:: Implementors of this interface should not return an empty
+            :class:`bytes` object, and users should ignore them.
 
         :param max_bytes: maximum number of bytes to receive
         :return: the received bytes
@@ -161,8 +166,8 @@ async def send_eof(self) -> None:
         """
         Send an end-of-file indication to the peer.
 
-        You should not try to send any further data to this stream after calling this method.
-        This method is idempotent (does nothing on successive calls).
+        You should not try to send any further data to this stream after calling this
+        method. This method is idempotent (does nothing on successive calls).
         """
 
 
@@ -182,17 +187,17 @@ async def send_eof(self) -> None:
 AnyByteStream = Union[ObjectStream[bytes], ByteStream]
 
 
-class Listener(Generic[T_Stream], AsyncResource, TypedAttributeProvider):
+class Listener(Generic[T_co], AsyncResource, TypedAttributeProvider):
     """An interface for objects that let you accept incoming connections."""
 
     @abstractmethod
     async def serve(
-        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+        self, handler: Callable[[T_co], Any], task_group: TaskGroup | None = None
     ) -> None:
         """
         Accept incoming connections as they come in and start tasks to handle them.
 
         :param handler: a callable that will be used to handle each accepted connection
-        :param task_group: the task group that will be used to start tasks for handling each
-            accepted connection (if omitted, an ad-hoc task group will be created)
+        :param task_group: the task group that will be used to start tasks for handling
+            each accepted connection (if omitted, an ad-hoc task group will be created)
         """
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_subprocesses.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_subprocesses.py
index d2f9583..ce0564c 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_subprocesses.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_subprocesses.py
@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from abc import abstractmethod
-from typing import Optional
+from signal import Signals
 
 from ._resources import AsyncResource
 from ._streams import ByteReceiveStream, ByteSendStream
@@ -39,7 +41,7 @@ def kill(self) -> None:
         """
 
     @abstractmethod
-    def send_signal(self, signal: int) -> None:
+    def send_signal(self, signal: Signals) -> None:
         """
         Send a signal to the subprocess.
 
@@ -55,23 +57,23 @@ def pid(self) -> int:
 
     @property
     @abstractmethod
-    def returncode(self) -> Optional[int]:
+    def returncode(self) -> int | None:
         """
-        The return code of the process. If the process has not yet terminated, this will be
-        ``None``.
+        The return code of the process. If the process has not yet terminated, this will
+        be ``None``.
         """
 
     @property
     @abstractmethod
-    def stdin(self) -> Optional[ByteSendStream]:
+    def stdin(self) -> ByteSendStream | None:
         """The stream for the standard input of the process."""
 
     @property
     @abstractmethod
-    def stdout(self) -> Optional[ByteReceiveStream]:
+    def stdout(self) -> ByteReceiveStream | None:
         """The stream for the standard output of the process."""
 
     @property
     @abstractmethod
-    def stderr(self) -> Optional[ByteReceiveStream]:
+    def stderr(self) -> ByteReceiveStream | None:
         """The stream for the standard error output of the process."""
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_tasks.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_tasks.py
index 615b7cc..7ad4938 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_tasks.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_tasks.py
@@ -1,18 +1,34 @@
-import typing
+from __future__ import annotations
+
+import sys
 from abc import ABCMeta, abstractmethod
+from collections.abc import Awaitable, Callable
 from types import TracebackType
-from typing import Callable, Coroutine, Optional, Type, TypeVar
-from warnings import warn
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, overload
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
 
-if typing.TYPE_CHECKING:
-    from anyio._core._tasks import CancelScope
+if TYPE_CHECKING:
+    from .._core._tasks import CancelScope
 
 T_Retval = TypeVar("T_Retval")
+T_contra = TypeVar("T_contra", contravariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
 
 
-class TaskStatus(metaclass=ABCMeta):
-    @abstractmethod
-    def started(self, value: object = None) -> None:
+class TaskStatus(Protocol[T_contra]):
+    @overload
+    def started(self: TaskStatus[None]) -> None:
+        ...
+
+    @overload
+    def started(self, value: T_contra) -> None:
+        ...
+
+    def started(self, value: T_contra | None = None) -> None:
         """
         Signal that the task has started.
 
@@ -28,32 +44,14 @@ class TaskGroup(metaclass=ABCMeta):
     :vartype cancel_scope: CancelScope
     """
 
-    cancel_scope: "CancelScope"
-
-    async def spawn(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
-    ) -> None:
-        """
-        Start a new task in this task group.
-
-        :param func: a coroutine function
-        :param args: positional arguments to call the function with
-        :param name: name of the task, for the purposes of introspection and debugging
-
-        .. deprecated:: 3.0
-           Use :meth:`start_soon` instead. If your code needs AnyIO 2 compatibility, you
-           can keep using this until AnyIO 4.
-
-        """
-        warn(
-            'spawn() is deprecated -- use start_soon() (without the "await") instead',
-            DeprecationWarning,
-        )
-        self.start_soon(func, *args, name=name)
+    cancel_scope: CancelScope
 
     @abstractmethod
     def start_soon(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[Any]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
     ) -> None:
         """
         Start a new task in this task group.
@@ -67,8 +65,11 @@ def start_soon(
 
     @abstractmethod
     async def start(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
-    ) -> object:
+        self,
+        func: Callable[..., Awaitable[Any]],
+        *args: object,
+        name: object = None,
+    ) -> Any:
         """
         Start a new task and wait until it signals for readiness.
 
@@ -76,20 +77,21 @@ async def start(
         :param args: positional arguments to call the function with
         :param name: name of the task, for the purposes of introspection and debugging
         :return: the value passed to ``task_status.started()``
-        :raises RuntimeError: if the task finishes without calling ``task_status.started()``
+        :raises RuntimeError: if the task finishes without calling
+            ``task_status.started()``
 
         .. versionadded:: 3.0
         """
 
     @abstractmethod
-    async def __aenter__(self) -> "TaskGroup":
+    async def __aenter__(self) -> TaskGroup:
         """Enter the task group context and allow starting new tasks."""
 
     @abstractmethod
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         """Exit the task group context waiting for all tasks to finish."""
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/abc/_testing.py b/addon/globalPlugins/spellcheck/libs/anyio/abc/_testing.py
index 2a5ab1e..4d70b9e 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/abc/_testing.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/abc/_testing.py
@@ -1,44 +1,66 @@
+from __future__ import annotations
+
 import types
 from abc import ABCMeta, abstractmethod
-from typing import Any, Awaitable, Callable, Dict, Optional, Type, TypeVar
+from collections.abc import AsyncGenerator, Callable, Coroutine, Iterable
+from typing import Any, TypeVar
 
 _T = TypeVar("_T")
 
 
 class TestRunner(metaclass=ABCMeta):
     """
-    Encapsulates a running event loop. Every call made through this object will use the same event
-    loop.
+    Encapsulates a running event loop. Every call made through this object will use the
+    same event loop.
     """
 
-    def __enter__(self) -> "TestRunner":
+    def __enter__(self) -> TestRunner:
         return self
 
+    @abstractmethod
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[types.TracebackType],
-    ) -> Optional[bool]:
-        self.close()
-        return None
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        ...
 
     @abstractmethod
-    def close(self) -> None:
-        """Close the event loop."""
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[_T, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[_T]:
+        """
+        Run an async generator fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: an iterator yielding the value yielded from the async generator
+        """
 
     @abstractmethod
-    def call(
+    def run_fixture(
         self,
-        func: Callable[..., Awaitable[_T]],
-        *args: object,
-        **kwargs: Dict[str, Any]
+        fixture_func: Callable[..., Coroutine[Any, Any, _T]],
+        kwargs: dict[str, Any],
     ) -> _T:
         """
-        Call the given function within the backend's event loop.
+        Run an async fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: the return value of the fixture function
+        """
+
+    @abstractmethod
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        """
+        Run an async test function.
 
-        :param func: a callable returning an awaitable
-        :param args: positional arguments to call ``func`` with
-        :param kwargs: keyword arguments to call ``func`` with
-        :return: the return value of ``func``
+        :param test_func: the test function
+        :param kwargs: keyword arguments to call the test function with
         """
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/from_thread.py b/addon/globalPlugins/spellcheck/libs/anyio/from_thread.py
index 603c94e..4a98703 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/from_thread.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/from_thread.py
@@ -1,38 +1,43 @@
+from __future__ import annotations
+
+import sys
 import threading
-from asyncio import iscoroutine
+from collections.abc import Awaitable, Callable, Generator
 from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
 from contextlib import AbstractContextManager, contextmanager
+from inspect import isawaitable
 from types import TracebackType
 from typing import (
     Any,
     AsyncContextManager,
-    Callable,
     ContextManager,
-    Coroutine,
-    Dict,
-    Generator,
+    Generic,
     Iterable,
-    Optional,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     cast,
     overload,
 )
-from warnings import warn
 
 from ._core import _eventloop
-from ._core._eventloop import get_asynclib, get_cancelled_exc_class, threadlocals
+from ._core._eventloop import get_async_backend, get_cancelled_exc_class, threadlocals
 from ._core._synchronization import Event
 from ._core._tasks import CancelScope, create_task_group
+from .abc import AsyncBackend
 from .abc._tasks import TaskStatus
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
 T_Retval = TypeVar("T_Retval")
-T_co = TypeVar("T_co")
+T_co = TypeVar("T_co", covariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
 
 
-def run(func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object) -> T_Retval:
+def run(
+    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]], *args: Unpack[PosArgsT]
+) -> T_Retval:
     """
     Call a coroutine function from a worker thread.
 
@@ -42,24 +47,19 @@ def run(func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object) -> T_
 
     """
     try:
-        asynclib = threadlocals.current_async_module
+        async_backend = threadlocals.current_async_backend
+        token = threadlocals.current_token
     except AttributeError:
-        raise RuntimeError("This function can only be run from an AnyIO worker thread")
+        raise RuntimeError(
+            "This function can only be run from an AnyIO worker thread"
+        ) from None
 
-    return asynclib.run_async_from_thread(func, *args)
+    return async_backend.run_async_from_thread(func, args, token=token)
 
 
-def run_async_from_thread(
-    func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
+def run_sync(
+    func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT]
 ) -> T_Retval:
-    warn(
-        "run_async_from_thread() has been deprecated, use anyio.from_thread.run() instead",
-        DeprecationWarning,
-    )
-    return run(func, *args)
-
-
-def run_sync(func: Callable[..., T_Retval], *args: object) -> T_Retval:
     """
     Call a function in the event loop thread from a worker thread.
 
@@ -69,34 +69,29 @@ def run_sync(func: Callable[..., T_Retval], *args: object) -> T_Retval:
 
     """
     try:
-        asynclib = threadlocals.current_async_module
+        async_backend = threadlocals.current_async_backend
+        token = threadlocals.current_token
     except AttributeError:
-        raise RuntimeError("This function can only be run from an AnyIO worker thread")
-
-    return asynclib.run_sync_from_thread(func, *args)
+        raise RuntimeError(
+            "This function can only be run from an AnyIO worker thread"
+        ) from None
 
+    return async_backend.run_sync_from_thread(func, args, token=token)
 
-def run_sync_from_thread(func: Callable[..., T_Retval], *args: object) -> T_Retval:
-    warn(
-        "run_sync_from_thread() has been deprecated, use anyio.from_thread.run_sync() instead",
-        DeprecationWarning,
-    )
-    return run_sync(func, *args)
 
-
-class _BlockingAsyncContextManager(AbstractContextManager):
-    _enter_future: Future
-    _exit_future: Future
+class _BlockingAsyncContextManager(Generic[T_co], AbstractContextManager):
+    _enter_future: Future[T_co]
+    _exit_future: Future[bool | None]
     _exit_event: Event
-    _exit_exc_info: Tuple[
-        Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]
-    ]
+    _exit_exc_info: tuple[
+        type[BaseException] | None, BaseException | None, TracebackType | None
+    ] = (None, None, None)
 
-    def __init__(self, async_cm: AsyncContextManager[T_co], portal: "BlockingPortal"):
+    def __init__(self, async_cm: AsyncContextManager[T_co], portal: BlockingPortal):
         self._async_cm = async_cm
         self._portal = portal
 
-    async def run_async_cm(self) -> Optional[bool]:
+    async def run_async_cm(self) -> bool | None:
         try:
             self._exit_event = Event()
             value = await self._async_cm.__aenter__()
@@ -106,21 +101,30 @@ async def run_async_cm(self) -> Optional[bool]:
         else:
             self._enter_future.set_result(value)
 
-        await self._exit_event.wait()
-        return await self._async_cm.__aexit__(*self._exit_exc_info)
+        try:
+            # Wait for the sync context manager to exit.
+            # This next statement can raise `get_cancelled_exc_class()` if
+            # something went wrong in a task group in this async context
+            # manager.
+            await self._exit_event.wait()
+        finally:
+            # In case of cancellation, it could be that we end up here before
+            # `_BlockingAsyncContextManager.__exit__` is called, and an
+            # `_exit_exc_info` has been set.
+            result = await self._async_cm.__aexit__(*self._exit_exc_info)
+            return result
 
     def __enter__(self) -> T_co:
         self._enter_future = Future()
         self._exit_future = self._portal.start_task_soon(self.run_async_cm)
-        cm = self._enter_future.result()
-        return cast(T_co, cm)
+        return self._enter_future.result()
 
     def __exit__(
         self,
-        __exc_type: Optional[Type[BaseException]],
-        __exc_value: Optional[BaseException],
-        __traceback: Optional[TracebackType],
-    ) -> Optional[bool]:
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool | None:
         self._exit_exc_info = __exc_type, __exc_value, __traceback
         self._portal.call(self._exit_event.set)
         return self._exit_future.result()
@@ -137,25 +141,25 @@ def started(self, value: object = None) -> None:
 class BlockingPortal:
     """An object that lets external threads run code in an asynchronous event loop."""
 
-    def __new__(cls) -> "BlockingPortal":
-        return get_asynclib().BlockingPortal()
+    def __new__(cls) -> BlockingPortal:
+        return get_async_backend().create_blocking_portal()
 
     def __init__(self) -> None:
-        self._event_loop_thread_id: Optional[int] = threading.get_ident()
+        self._event_loop_thread_id: int | None = threading.get_ident()
         self._stop_event = Event()
         self._task_group = create_task_group()
         self._cancelled_exc_class = get_cancelled_exc_class()
 
-    async def __aenter__(self) -> "BlockingPortal":
+    async def __aenter__(self) -> BlockingPortal:
         await self._task_group.__aenter__()
         return self
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Optional[bool]:
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
         await self.stop()
         return await self._task_group.__aexit__(exc_type, exc_val, exc_tb)
 
@@ -178,8 +182,8 @@ async def stop(self, cancel_remaining: bool = False) -> None:
         This marks the portal as no longer accepting new calls and exits from
         :meth:`sleep_until_stopped`.
 
-        :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False`` to let them
-            finish before returning
+        :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False``
+            to let them finish before returning
 
         """
         self._event_loop_thread_id = None
@@ -188,9 +192,13 @@ async def stop(self, cancel_remaining: bool = False) -> None:
             self._task_group.cancel_scope.cancel()
 
     async def _call_func(
-        self, func: Callable, args: tuple, kwargs: Dict[str, Any], future: Future
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        future: Future[T_Retval],
     ) -> None:
-        def callback(f: Future) -> None:
+        def callback(f: Future[T_Retval]) -> None:
             if f.cancelled() and self._event_loop_thread_id not in (
                 None,
                 threading.get_ident(),
@@ -198,17 +206,20 @@ def callback(f: Future) -> None:
                 self.call(scope.cancel)
 
         try:
-            retval = func(*args, **kwargs)
-            if iscoroutine(retval):
+            retval_or_awaitable = func(*args, **kwargs)
+            if isawaitable(retval_or_awaitable):
                 with CancelScope() as scope:
                     if future.cancelled():
                         scope.cancel()
                     else:
                         future.add_done_callback(callback)
 
-                    retval = await retval
+                    retval = await retval_or_awaitable
+            else:
+                retval = retval_or_awaitable
         except self._cancelled_exc_class:
             future.cancel()
+            future.set_running_or_notify_cancel()
         except BaseException as exc:
             if not future.cancelled():
                 future.set_exception(exc)
@@ -224,11 +235,11 @@ def callback(f: Future) -> None:
 
     def _spawn_task_from_thread(
         self,
-        func: Callable,
-        args: tuple,
-        kwargs: Dict[str, Any],
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
         name: object,
-        future: Future,
+        future: Future[T_Retval],
     ) -> None:
         """
         Spawn a new task using the given callable.
@@ -239,26 +250,30 @@ def _spawn_task_from_thread(
         :param args: positional arguments to be passed to the callable
         :param kwargs: keyword arguments to be passed to the callable
         :param name: name of the task (will be coerced to a string if not ``None``)
-        :param future: a future that will resolve to the return value of the callable, or the
-            exception raised during its execution
+        :param future: a future that will resolve to the return value of the callable,
+            or the exception raised during its execution
 
         """
         raise NotImplementedError
 
     @overload
     def call(
-        self, func: Callable[..., Coroutine[Any, Any, T_Retval]], *args: object
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        *args: Unpack[PosArgsT],
     ) -> T_Retval:
         ...
 
     @overload
-    def call(self, func: Callable[..., T_Retval], *args: object) -> T_Retval:
+    def call(
+        self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT]
+    ) -> T_Retval:
         ...
 
     def call(
         self,
-        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
-        *args: object
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        *args: Unpack[PosArgsT],
     ) -> T_Retval:
         """
         Call the given function in the event loop thread.
@@ -266,118 +281,83 @@ def call(
         If the callable returns a coroutine object, it is awaited on.
 
         :param func: any callable
-        :raises RuntimeError: if the portal is not running or if this method is called from within
-            the event loop thread
+        :raises RuntimeError: if the portal is not running or if this method is called
+            from within the event loop thread
 
         """
         return cast(T_Retval, self.start_task_soon(func, *args).result())
 
-    @overload
-    def spawn_task(
-        self,
-        func: Callable[..., Coroutine[Any, Any, T_Retval]],
-        *args: object,
-        name: object = None
-    ) -> "Future[T_Retval]":
-        ...
-
-    @overload
-    def spawn_task(
-        self, func: Callable[..., T_Retval], *args: object, name: object = None
-    ) -> "Future[T_Retval]":
-        ...
-
-    def spawn_task(
-        self,
-        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
-        *args: object,
-        name: object = None
-    ) -> "Future[T_Retval]":
-        """
-        Start a task in the portal's task group.
-
-        :param func: the target coroutine function
-        :param args: positional arguments passed to ``func``
-        :param name: name of the task (will be coerced to a string if not ``None``)
-        :return: a future that resolves with the return value of the callable if the task completes
-            successfully, or with the exception raised in the task
-        :raises RuntimeError: if the portal is not running or if this method is called from within
-            the event loop thread
-
-        .. versionadded:: 2.1
-        .. deprecated:: 3.0
-           Use :meth:`start_task_soon` instead. If your code needs AnyIO 2 compatibility, you
-           can keep using this until AnyIO 4.
-
-        """
-        warn(
-            "spawn_task() is deprecated -- use start_task_soon() instead",
-            DeprecationWarning,
-        )
-        return self.start_task_soon(func, *args, name=name)  # type: ignore[arg-type]
-
     @overload
     def start_task_soon(
         self,
-        func: Callable[..., Coroutine[Any, Any, T_Retval]],
-        *args: object,
-        name: object = None
-    ) -> "Future[T_Retval]":
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]:
         ...
 
     @overload
     def start_task_soon(
-        self, func: Callable[..., T_Retval], *args: object, name: object = None
-    ) -> "Future[T_Retval]":
+        self,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]:
         ...
 
     def start_task_soon(
         self,
-        func: Callable[..., Union[Coroutine[Any, Any, T_Retval], T_Retval]],
-        *args: object,
-        name: object = None
-    ) -> "Future[T_Retval]":
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]:
         """
         Start a task in the portal's task group.
 
-        The task will be run inside a cancel scope which can be cancelled by cancelling the
-        returned future.
+        The task will be run inside a cancel scope which can be cancelled by cancelling
+        the returned future.
 
-        :param func: the target coroutine function
+        :param func: the target function
         :param args: positional arguments passed to ``func``
         :param name: name of the task (will be coerced to a string if not ``None``)
-        :return: a future that resolves with the return value of the callable if the task completes
-            successfully, or with the exception raised in the task
-        :raises RuntimeError: if the portal is not running or if this method is called from within
-            the event loop thread
+        :return: a future that resolves with the return value of the callable if the
+            task completes successfully, or with the exception raised in the task
+        :raises RuntimeError: if the portal is not running or if this method is called
+            from within the event loop thread
+        :rtype: concurrent.futures.Future[T_Retval]
 
         .. versionadded:: 3.0
 
         """
         self._check_running()
-        f: Future = Future()
+        f: Future[T_Retval] = Future()
         self._spawn_task_from_thread(func, args, {}, name, f)
         return f
 
     def start_task(
-        self, func: Callable[..., Coroutine], *args: object, name: object = None
-    ) -> Tuple[Future, Any]:
+        self,
+        func: Callable[..., Awaitable[T_Retval]],
+        *args: object,
+        name: object = None,
+    ) -> tuple[Future[T_Retval], Any]:
         """
         Start a task in the portal's task group and wait until it signals for readiness.
 
-        This method works the same way as :meth:`TaskGroup.start`.
+        This method works the same way as :meth:`.abc.TaskGroup.start`.
 
-        :param func: the target coroutine function
+        :param func: the target function
         :param args: positional arguments passed to ``func``
         :param name: name of the task (will be coerced to a string if not ``None``)
-        :return: a tuple of (future, task_status_value) where the ``task_status_value`` is the
-            value passed to ``task_status.started()`` from within the target function
+        :return: a tuple of (future, task_status_value) where the ``task_status_value``
+            is the value passed to ``task_status.started()`` from within the target
+            function
+        :rtype: tuple[concurrent.futures.Future[T_Retval], Any]
 
         .. versionadded:: 3.0
 
         """
 
-        def task_done(future: Future) -> None:
+        def task_done(future: Future[T_Retval]) -> None:
             if not task_status_future.done():
                 if future.cancelled():
                     task_status_future.cancel()
@@ -403,8 +383,8 @@ def wrap_async_context_manager(
         """
         Wrap an async context manager as a synchronous context manager via this portal.
 
-        Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping in the
-        middle until the synchronous context manager exits.
+        Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping
+        in the middle until the synchronous context manager exits.
 
         :param cm: an asynchronous context manager
         :return: a synchronous context manager
@@ -415,28 +395,9 @@ def wrap_async_context_manager(
         return _BlockingAsyncContextManager(cm, self)
 
 
-def create_blocking_portal() -> BlockingPortal:
-    """
-    Create a portal for running functions in the event loop thread from external threads.
-
-    Use this function in asynchronous code when you need to allow external threads access to the
-    event loop where your asynchronous code is currently running.
-
-    .. deprecated:: 3.0
-        Use :class:`.BlockingPortal` directly.
-
-    """
-    warn(
-        "create_blocking_portal() has been deprecated -- use anyio.from_thread.BlockingPortal() "
-        "directly",
-        DeprecationWarning,
-    )
-    return BlockingPortal()
-
-
 @contextmanager
 def start_blocking_portal(
-    backend: str = "asyncio", backend_options: Optional[Dict[str, Any]] = None
+    backend: str = "asyncio", backend_options: dict[str, Any] | None = None
 ) -> Generator[BlockingPortal, Any, None]:
     """
     Start a new event loop in a new thread and run a blocking portal in its main task.
@@ -461,7 +422,10 @@ async def run_portal() -> None:
     future: Future[BlockingPortal] = Future()
     with ThreadPoolExecutor(1) as executor:
         run_future = executor.submit(
-            _eventloop.run, run_portal, backend=backend, backend_options=backend_options
+            _eventloop.run,  # type: ignore[arg-type]
+            run_portal,
+            backend=backend,
+            backend_options=backend_options,
         )
         try:
             wait(
@@ -475,12 +439,38 @@ async def run_portal() -> None:
 
         if future.done():
             portal = future.result()
+            cancel_remaining_tasks = False
             try:
                 yield portal
             except BaseException:
-                portal.call(portal.stop, True)
+                cancel_remaining_tasks = True
                 raise
-
-            portal.call(portal.stop, False)
+            finally:
+                try:
+                    portal.call(portal.stop, cancel_remaining_tasks)
+                except RuntimeError:
+                    pass
 
         run_future.result()
+
+
+def check_cancelled() -> None:
+    """
+    Check if the cancel scope of the host task's running the current worker thread has
+    been cancelled.
+
+    If the host task's current cancel scope has indeed been cancelled, the
+    backend-specific cancellation exception will be raised.
+
+    :raises RuntimeError: if the current thread was not spawned by
+        :func:`.to_thread.run_sync`
+
+    """
+    try:
+        async_backend: AsyncBackend = threadlocals.current_async_backend
+    except AttributeError:
+        raise RuntimeError(
+            "This function can only be run from an AnyIO worker thread"
+        ) from None
+
+    async_backend.check_cancelled()
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/lowlevel.py b/addon/globalPlugins/spellcheck/libs/anyio/lowlevel.py
index 79f4ce8..a9e10f4 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/lowlevel.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/lowlevel.py
@@ -1,15 +1,11 @@
+from __future__ import annotations
+
 import enum
-import sys
 from dataclasses import dataclass
-from typing import Any, Dict, Generic, Set, TypeVar, Union, overload
+from typing import Any, Generic, Literal, TypeVar, overload
 from weakref import WeakKeyDictionary
 
-from ._core._eventloop import get_asynclib
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
+from ._core._eventloop import get_async_backend
 
 T = TypeVar("T")
 D = TypeVar("D")
@@ -24,10 +20,11 @@ async def checkpoint() -> None:
         await checkpoint_if_cancelled()
         await cancel_shielded_checkpoint()
 
+
     .. versionadded:: 3.0
 
     """
-    await get_asynclib().checkpoint()
+    await get_async_backend().checkpoint()
 
 
 async def checkpoint_if_cancelled() -> None:
@@ -39,7 +36,7 @@ async def checkpoint_if_cancelled() -> None:
     .. versionadded:: 3.0
 
     """
-    await get_asynclib().checkpoint_if_cancelled()
+    await get_async_backend().checkpoint_if_cancelled()
 
 
 async def cancel_shielded_checkpoint() -> None:
@@ -51,19 +48,24 @@ async def cancel_shielded_checkpoint() -> None:
         with CancelScope(shield=True):
             await checkpoint()
 
+
     .. versionadded:: 3.0
 
     """
-    await get_asynclib().cancel_shielded_checkpoint()
+    await get_async_backend().cancel_shielded_checkpoint()
 
 
 def current_token() -> object:
-    """Return a backend specific token object that can be used to get back to the event loop."""
-    return get_asynclib().current_token()
+    """
+    Return a backend specific token object that can be used to get back to the event
+    loop.
+
+    """
+    return get_async_backend().current_token()
 
 
-_run_vars = WeakKeyDictionary()  # type: WeakKeyDictionary[Any, Dict[str, Any]]
-_token_wrappers: Dict[Any, "_TokenWrapper"] = {}
+_run_vars: WeakKeyDictionary[Any, dict[str, Any]] = WeakKeyDictionary()
+_token_wrappers: dict[Any, _TokenWrapper] = {}
 
 
 @dataclass(frozen=True)
@@ -79,49 +81,40 @@ class _NoValueSet(enum.Enum):
 class RunvarToken(Generic[T]):
     __slots__ = "_var", "_value", "_redeemed"
 
-    def __init__(
-        self, var: "RunVar", value: Union[T, Literal[_NoValueSet.NO_VALUE_SET]]
-    ):
+    def __init__(self, var: RunVar[T], value: T | Literal[_NoValueSet.NO_VALUE_SET]):
         self._var = var
-        self._value: Union[T, Literal[_NoValueSet.NO_VALUE_SET]] = value
+        self._value: T | Literal[_NoValueSet.NO_VALUE_SET] = value
         self._redeemed = False
 
 
 class RunVar(Generic[T]):
-    """Like a :class:`~contextvars.ContextVar`, expect scoped to the running event loop."""
+    """
+    Like a :class:`~contextvars.ContextVar`, except scoped to the running event loop.
+    """
 
     __slots__ = "_name", "_default"
 
     NO_VALUE_SET: Literal[_NoValueSet.NO_VALUE_SET] = _NoValueSet.NO_VALUE_SET
 
-    _token_wrappers: Set[_TokenWrapper] = set()
+    _token_wrappers: set[_TokenWrapper] = set()
 
     def __init__(
-        self,
-        name: str,
-        default: Union[T, Literal[_NoValueSet.NO_VALUE_SET]] = NO_VALUE_SET,
+        self, name: str, default: T | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET
     ):
         self._name = name
         self._default = default
 
     @property
-    def _current_vars(self) -> Dict[str, T]:
+    def _current_vars(self) -> dict[str, T]:
         token = current_token()
-        while True:
-            try:
-                return _run_vars[token]
-            except TypeError:
-                # Happens when token isn't weak referable (TrioToken).
-                # This workaround does mean that some memory will leak on Trio until the problem
-                # is fixed on their end.
-                token = _TokenWrapper(token)
-                self._token_wrappers.add(token)
-            except KeyError:
-                run_vars = _run_vars[token] = {}
-                return run_vars
+        try:
+            return _run_vars[token]
+        except KeyError:
+            run_vars = _run_vars[token] = {}
+            return run_vars
 
     @overload
-    def get(self, default: D) -> Union[T, D]:
+    def get(self, default: D) -> T | D:
         ...
 
     @overload
@@ -129,8 +122,8 @@ def get(self) -> T:
         ...
 
     def get(
-        self, default: Union[D, Literal[_NoValueSet.NO_VALUE_SET]] = NO_VALUE_SET
-    ) -> Union[T, D]:
+        self, default: D | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET
+    ) -> T | D:
         try:
             return self._current_vars[self._name]
         except KeyError:
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/pytest_plugin.py b/addon/globalPlugins/spellcheck/libs/anyio/pytest_plugin.py
index 62d243e..a8dd6f3 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/pytest_plugin.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/pytest_plugin.py
@@ -1,20 +1,22 @@
-from contextlib import contextmanager
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import ExitStack, contextmanager
 from inspect import isasyncgenfunction, iscoroutinefunction
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Tuple, cast
+from typing import Any, Dict, Tuple, cast
 
 import pytest
 import sniffio
 
-from ._core._eventloop import get_all_backends, get_asynclib
+from ._core._eventloop import get_all_backends, get_async_backend
 from .abc import TestRunner
 
-if TYPE_CHECKING:
-    from _pytest.config import Config
-
-_current_runner: Optional[TestRunner] = None
+_current_runner: TestRunner | None = None
+_runner_stack: ExitStack | None = None
+_runner_leases = 0
 
 
-def extract_backend_and_options(backend: object) -> Tuple[str, Dict[str, Any]]:
+def extract_backend_and_options(backend: object) -> tuple[str, dict[str, Any]]:
     if isinstance(backend, str):
         return backend, {}
     elif isinstance(backend, tuple) and len(backend) == 2:
@@ -26,31 +28,35 @@ def extract_backend_and_options(backend: object) -> Tuple[str, Dict[str, Any]]:
 
 @contextmanager
 def get_runner(
-    backend_name: str, backend_options: Dict[str, Any]
+    backend_name: str, backend_options: dict[str, Any]
 ) -> Iterator[TestRunner]:
-    global _current_runner
-    if _current_runner:
-        yield _current_runner
-        return
+    global _current_runner, _runner_leases, _runner_stack
+    if _current_runner is None:
+        asynclib = get_async_backend(backend_name)
+        _runner_stack = ExitStack()
+        if sniffio.current_async_library_cvar.get(None) is None:
+            # Since we're in control of the event loop, we can cache the name of the
+            # async library
+            token = sniffio.current_async_library_cvar.set(backend_name)
+            _runner_stack.callback(sniffio.current_async_library_cvar.reset, token)
 
-    asynclib = get_asynclib(backend_name)
-    token = None
-    if sniffio.current_async_library_cvar.get(None) is None:
-        # Since we're in control of the event loop, we can cache the name of the async library
-        token = sniffio.current_async_library_cvar.set(backend_name)
+        backend_options = backend_options or {}
+        _current_runner = _runner_stack.enter_context(
+            asynclib.create_test_runner(backend_options)
+        )
 
+    _runner_leases += 1
     try:
-        backend_options = backend_options or {}
-        with asynclib.TestRunner(**backend_options) as runner:
-            _current_runner = runner
-            yield runner
+        yield _current_runner
     finally:
-        _current_runner = None
-        if token:
-            sniffio.current_async_library_cvar.reset(token)
+        _runner_leases -= 1
+        if not _runner_leases:
+            assert _runner_stack is not None
+            _runner_stack.close()
+            _runner_stack = _current_runner = None
 
 
-def pytest_configure(config: "Config") -> None:
+def pytest_configure(config: Any) -> None:
     config.addinivalue_line(
         "markers",
         "anyio: mark the (coroutine function) test to be run "
@@ -66,26 +72,12 @@ def wrapper(*args, anyio_backend, **kwargs):  # type: ignore[no-untyped-def]
 
         with get_runner(backend_name, backend_options) as runner:
             if isasyncgenfunction(func):
-                gen = func(*args, **kwargs)
-                try:
-                    value = runner.call(gen.asend, None)
-                except StopAsyncIteration:
-                    raise RuntimeError("Async generator did not yield")
-
-                yield value
-
-                try:
-                    runner.call(gen.asend, None)
-                except StopAsyncIteration:
-                    pass
-                else:
-                    runner.call(gen.aclose)
-                    raise RuntimeError("Async generator fixture did not stop")
+                yield from runner.run_asyncgen_fixture(func, kwargs)
             else:
-                yield runner.call(func, *args, **kwargs)
+                yield runner.run_fixture(func, kwargs)
 
-    # Only apply this to coroutine functions and async generator functions in requests that involve
-    # the anyio_backend fixture
+    # Only apply this to coroutine functions and async generator functions in requests
+    # that involve the anyio_backend fixture
     func = fixturedef.func
     if isasyncgenfunction(func) or iscoroutinefunction(func):
         if "anyio_backend" in request.fixturenames:
@@ -107,10 +99,10 @@ def pytest_pycollect_makeitem(collector: Any, name: Any, obj: Any) -> None:
 
 
 @pytest.hookimpl(tryfirst=True)
-def pytest_pyfunc_call(pyfuncitem: Any) -> Optional[bool]:
+def pytest_pyfunc_call(pyfuncitem: Any) -> bool | None:
     def run_with_hypothesis(**kwargs: Any) -> None:
         with get_runner(backend_name, backend_options) as runner:
-            runner.call(original_func, **kwargs)
+            runner.run_test(original_func, kwargs)
 
     backend = pyfuncitem.funcargs.get("anyio_backend")
     if backend:
@@ -129,14 +121,14 @@ def run_with_hypothesis(**kwargs: Any) -> None:
             funcargs = pyfuncitem.funcargs
             testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames}
             with get_runner(backend_name, backend_options) as runner:
-                runner.call(pyfuncitem.obj, **testargs)
+                runner.run_test(pyfuncitem.obj, testargs)
 
             return True
 
     return None
 
 
-@pytest.fixture(params=get_all_backends())
+@pytest.fixture(scope="module", params=get_all_backends())
 def anyio_backend(request: Any) -> Any:
     return request.param
 
@@ -150,7 +142,7 @@ def anyio_backend_name(anyio_backend: Any) -> str:
 
 
 @pytest.fixture
-def anyio_backend_options(anyio_backend: Any) -> Dict[str, Any]:
+def anyio_backend_options(anyio_backend: Any) -> dict[str, Any]:
     if isinstance(anyio_backend, str):
         return {}
     else:
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/buffered.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/buffered.py
index 1503b3e..f5d5e83 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/buffered.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/buffered.py
@@ -1,5 +1,8 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
-from typing import Any, Callable, Mapping
+from typing import Any
 
 from .. import ClosedResourceError, DelimiterNotFound, EndOfStream, IncompleteRead
 from ..abc import AnyByteReceiveStream, ByteReceiveStream
@@ -8,8 +11,8 @@
 @dataclass(eq=False)
 class BufferedByteReceiveStream(ByteReceiveStream):
     """
-    Wraps any bytes-based receive stream and uses a buffer to provide sophisticated receiving
-    capabilities in the form of a byte stream.
+    Wraps any bytes-based receive stream and uses a buffer to provide sophisticated
+    receiving capabilities in the form of a byte stream.
     """
 
     receive_stream: AnyByteReceiveStream
@@ -40,8 +43,8 @@ async def receive(self, max_bytes: int = 65536) -> bytes:
         elif isinstance(self.receive_stream, ByteReceiveStream):
             return await self.receive_stream.receive(max_bytes)
         else:
-            # With a bytes-oriented object stream, we need to handle any surplus bytes we get from
-            # the receive() call
+            # With a bytes-oriented object stream, we need to handle any surplus bytes
+            # we get from the receive() call
             chunk = await self.receive_stream.receive()
             if len(chunk) > max_bytes:
                 # Save the surplus bytes in the buffer
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/file.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/file.py
index b888378..f492464 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/file.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/file.py
@@ -1,7 +1,10 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
 from io import SEEK_SET, UnsupportedOperation
 from os import PathLike
 from pathlib import Path
-from typing import Any, BinaryIO, Callable, Dict, Mapping, Union, cast
+from typing import Any, BinaryIO, cast
 
 from .. import (
     BrokenResourceError,
@@ -32,7 +35,7 @@ async def aclose(self) -> None:
 
     @property
     def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
-        attributes: Dict[Any, Callable[[], Any]] = {
+        attributes: dict[Any, Callable[[], Any]] = {
             FileStreamAttribute.file: lambda: self._file,
         }
 
@@ -59,7 +62,7 @@ class FileReadStream(_BaseFileStream, ByteReceiveStream):
     """
 
     @classmethod
-    async def from_path(cls, path: Union[str, PathLike]) -> "FileReadStream":
+    async def from_path(cls, path: str | PathLike[str]) -> FileReadStream:
         """
         Create a file read stream by opening the given file.
 
@@ -122,14 +125,14 @@ class FileWriteStream(_BaseFileStream, ByteSendStream):
 
     @classmethod
     async def from_path(
-        cls, path: Union[str, PathLike], append: bool = False
-    ) -> "FileWriteStream":
+        cls, path: str | PathLike[str], append: bool = False
+    ) -> FileWriteStream:
         """
         Create a file write stream by opening the given file for writing.
 
         :param path: path of the file to write to
-        :param append: if ``True``, open the file for appending; if ``False``, any existing file
-            at the given path will be truncated
+        :param append: if ``True``, open the file for appending; if ``False``, any
+            existing file at the given path will be truncated
 
         """
         mode = "ab" if append else "wb"
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/memory.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/memory.py
index 5043fae..bc2425b 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/memory.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/memory.py
@@ -1,20 +1,22 @@
+from __future__ import annotations
+
 from collections import OrderedDict, deque
 from dataclasses import dataclass, field
 from types import TracebackType
-from typing import Deque, Generic, List, NamedTuple, Optional, Type, TypeVar
+from typing import Generic, NamedTuple, TypeVar
 
 from .. import (
     BrokenResourceError,
     ClosedResourceError,
     EndOfStream,
     WouldBlock,
-    get_cancelled_exc_class,
 )
-from .._core._compat import DeprecatedAwaitable
 from ..abc import Event, ObjectReceiveStream, ObjectSendStream
 from ..lowlevel import checkpoint
 
 T_Item = TypeVar("T_Item")
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
 
 
 class MemoryObjectStreamStatistics(NamedTuple):
@@ -23,7 +25,8 @@ class MemoryObjectStreamStatistics(NamedTuple):
     max_buffer_size: float
     open_send_streams: int  #: number of unclosed clones of the send stream
     open_receive_streams: int  #: number of unclosed clones of the receive stream
-    tasks_waiting_send: int  #: number of tasks blocked on :meth:`MemoryObjectSendStream.send`
+    #: number of tasks blocked on :meth:`MemoryObjectSendStream.send`
+    tasks_waiting_send: int
     #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive`
     tasks_waiting_receive: int
 
@@ -31,13 +34,13 @@ class MemoryObjectStreamStatistics(NamedTuple):
 @dataclass(eq=False)
 class MemoryObjectStreamState(Generic[T_Item]):
     max_buffer_size: float = field()
-    buffer: Deque[T_Item] = field(init=False, default_factory=deque)
+    buffer: deque[T_Item] = field(init=False, default_factory=deque)
     open_send_channels: int = field(init=False, default=0)
     open_receive_channels: int = field(init=False, default=0)
-    waiting_receivers: "OrderedDict[Event, List[T_Item]]" = field(
+    waiting_receivers: OrderedDict[Event, list[T_Item]] = field(
         init=False, default_factory=OrderedDict
     )
-    waiting_senders: "OrderedDict[Event, T_Item]" = field(
+    waiting_senders: OrderedDict[Event, T_Item] = field(
         init=False, default_factory=OrderedDict
     )
 
@@ -53,14 +56,14 @@ def statistics(self) -> MemoryObjectStreamStatistics:
 
 
 @dataclass(eq=False)
-class MemoryObjectReceiveStream(Generic[T_Item], ObjectReceiveStream[T_Item]):
-    _state: MemoryObjectStreamState[T_Item]
+class MemoryObjectReceiveStream(Generic[T_co], ObjectReceiveStream[T_co]):
+    _state: MemoryObjectStreamState[T_co]
     _closed: bool = field(init=False, default=False)
 
     def __post_init__(self) -> None:
         self._state.open_receive_channels += 1
 
-    def receive_nowait(self) -> T_Item:
+    def receive_nowait(self) -> T_co:
         """
         Receive the next item if it can be done without waiting.
 
@@ -88,23 +91,18 @@ def receive_nowait(self) -> T_Item:
 
         raise WouldBlock
 
-    async def receive(self) -> T_Item:
+    async def receive(self) -> T_co:
         await checkpoint()
         try:
             return self.receive_nowait()
         except WouldBlock:
             # Add ourselves in the queue
             receive_event = Event()
-            container: List[T_Item] = []
+            container: list[T_co] = []
             self._state.waiting_receivers[receive_event] = container
 
             try:
                 await receive_event.wait()
-            except get_cancelled_exc_class():
-                # Ignore the immediate cancellation if we already received an item, so as not to
-                # lose it
-                if not container:
-                    raise
             finally:
                 self._state.waiting_receivers.pop(receive_event, None)
 
@@ -113,12 +111,12 @@ async def receive(self) -> T_Item:
             else:
                 raise EndOfStream
 
-    def clone(self) -> "MemoryObjectReceiveStream":
+    def clone(self) -> MemoryObjectReceiveStream[T_co]:
         """
         Create a clone of this receive stream.
 
-        Each clone can be closed separately. Only when all clones have been closed will the
-        receiving end of the memory stream be considered closed by the sending ends.
+        Each clone can be closed separately. Only when all clones have been closed will
+        the receiving end of the memory stream be considered closed by the sending ends.
 
         :return: the cloned stream
 
@@ -132,8 +130,8 @@ def close(self) -> None:
         """
         Close the stream.
 
-        This works the exact same way as :meth:`aclose`, but is provided as a special case for the
-        benefit of synchronous callbacks.
+        This works the exact same way as :meth:`aclose`, but is provided as a special
+        case for the benefit of synchronous callbacks.
 
         """
         if not self._closed:
@@ -155,27 +153,27 @@ def statistics(self) -> MemoryObjectStreamStatistics:
         """
         return self._state.statistics()
 
-    def __enter__(self) -> "MemoryObjectReceiveStream[T_Item]":
+    def __enter__(self) -> MemoryObjectReceiveStream[T_co]:
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.close()
 
 
 @dataclass(eq=False)
-class MemoryObjectSendStream(Generic[T_Item], ObjectSendStream[T_Item]):
-    _state: MemoryObjectStreamState[T_Item]
+class MemoryObjectSendStream(Generic[T_contra], ObjectSendStream[T_contra]):
+    _state: MemoryObjectStreamState[T_contra]
     _closed: bool = field(init=False, default=False)
 
     def __post_init__(self) -> None:
         self._state.open_send_channels += 1
 
-    def send_nowait(self, item: T_Item) -> DeprecatedAwaitable:
+    def send_nowait(self, item: T_contra) -> None:
         """
         Send an item immediately if it can be done without waiting.
 
@@ -201,9 +199,19 @@ def send_nowait(self, item: T_Item) -> DeprecatedAwaitable:
         else:
             raise WouldBlock
 
-        return DeprecatedAwaitable(self.send_nowait)
+    async def send(self, item: T_contra) -> None:
+        """
+        Send an item to the stream.
+
+        If the buffer is full, this method blocks until there is again room in the
+        buffer or the item can be sent directly to a receiver.
 
-    async def send(self, item: T_Item) -> None:
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
+            receiving end
+
+        """
         await checkpoint()
         try:
             self.send_nowait(item)
@@ -214,18 +222,18 @@ async def send(self, item: T_Item) -> None:
             try:
                 await send_event.wait()
             except BaseException:
-                self._state.waiting_senders.pop(send_event, None)  # type: ignore[arg-type]
+                self._state.waiting_senders.pop(send_event, None)
                 raise
 
-            if self._state.waiting_senders.pop(send_event, None):  # type: ignore[arg-type]
-                raise BrokenResourceError
+            if self._state.waiting_senders.pop(send_event, None):
+                raise BrokenResourceError from None
 
-    def clone(self) -> "MemoryObjectSendStream":
+    def clone(self) -> MemoryObjectSendStream[T_contra]:
         """
         Create a clone of this send stream.
 
-        Each clone can be closed separately. Only when all clones have been closed will the
-        sending end of the memory stream be considered closed by the receiving ends.
+        Each clone can be closed separately. Only when all clones have been closed will
+        the sending end of the memory stream be considered closed by the receiving ends.
 
         :return: the cloned stream
 
@@ -239,8 +247,8 @@ def close(self) -> None:
         """
         Close the stream.
 
-        This works the exact same way as :meth:`aclose`, but is provided as a special case for the
-        benefit of synchronous callbacks.
+        This works the exact same way as :meth:`aclose`, but is provided as a special
+        case for the benefit of synchronous callbacks.
 
         """
         if not self._closed:
@@ -263,13 +271,13 @@ def statistics(self) -> MemoryObjectStreamStatistics:
         """
         return self._state.statistics()
 
-    def __enter__(self) -> "MemoryObjectSendStream[T_Item]":
+    def __enter__(self) -> MemoryObjectSendStream[T_contra]:
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.close()
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/stapled.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/stapled.py
index a71ffb0..80f64a2 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/stapled.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/stapled.py
@@ -1,5 +1,8 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, TypeVar
+from typing import Any, Generic, TypeVar
 
 from ..abc import (
     ByteReceiveStream,
@@ -21,8 +24,8 @@ class StapledByteStream(ByteStream):
     """
     Combines two byte streams into a single, bidirectional byte stream.
 
-    Extra attributes will be provided from both streams, with the receive stream providing the
-    values in case of a conflict.
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
 
     :param ByteSendStream send_stream: the sending byte stream
     :param ByteReceiveStream receive_stream: the receiving byte stream
@@ -57,8 +60,8 @@ class StapledObjectStream(Generic[T_Item], ObjectStream[T_Item]):
     """
     Combines two object streams into a single, bidirectional object stream.
 
-    Extra attributes will be provided from both streams, with the receive stream providing the
-    values in case of a conflict.
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
 
     :param ObjectSendStream send_stream: the sending object stream
     :param ObjectReceiveStream receive_stream: the receiving object stream
@@ -93,11 +96,11 @@ class MultiListener(Generic[T_Stream], Listener[T_Stream]):
     """
     Combines multiple listeners into one, serving connections from all of them at once.
 
-    Any MultiListeners in the given collection of listeners will have their listeners moved into
-    this one.
+    Any MultiListeners in the given collection of listeners will have their listeners
+    moved into this one.
 
-    Extra attributes are provided from each listener, with each successive listener overriding any
-    conflicting attributes from the previous one.
+    Extra attributes are provided from each listener, with each successive listener
+    overriding any conflicting attributes from the previous one.
 
     :param listeners: listeners to serve
     :type listeners: Sequence[Listener[T_Stream]]
@@ -106,7 +109,7 @@ class MultiListener(Generic[T_Stream], Listener[T_Stream]):
     listeners: Sequence[Listener[T_Stream]]
 
     def __post_init__(self) -> None:
-        listeners: List[Listener[T_Stream]] = []
+        listeners: list[Listener[T_Stream]] = []
         for listener in self.listeners:
             if isinstance(listener, MultiListener):
                 listeners.extend(listener.listeners)
@@ -117,7 +120,7 @@ def __post_init__(self) -> None:
         self.listeners = listeners
 
     async def serve(
-        self, handler: Callable[[T_Stream], Any], task_group: Optional[TaskGroup] = None
+        self, handler: Callable[[T_Stream], Any], task_group: TaskGroup | None = None
     ) -> None:
         from .. import create_task_group
 
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/text.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/text.py
index ccb683c..f1a1127 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/text.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/text.py
@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import codecs
+from collections.abc import Callable, Mapping
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Callable, Mapping, Tuple
+from typing import Any
 
 from ..abc import (
     AnyByteReceiveStream,
@@ -17,16 +20,17 @@ class TextReceiveStream(ObjectReceiveStream[str]):
     """
     Stream wrapper that decodes bytes to strings using the given encoding.
 
-    Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any completely
-    received unicode characters as soon as they come in.
+    Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any
+    completely received unicode characters as soon as they come in.
 
     :param transport_stream: any bytes-based receive stream
-    :param encoding: character encoding to use for decoding bytes to strings (defaults to
-        ``utf-8``)
+    :param encoding: character encoding to use for decoding bytes to strings (defaults
+        to ``utf-8``)
     :param errors: handling scheme for decoding errors (defaults to ``strict``; see the
         `codecs module documentation`_ for a comprehensive list of options)
 
-    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
     """
 
     transport_stream: AnyByteReceiveStream
@@ -60,18 +64,19 @@ class TextSendStream(ObjectSendStream[str]):
     Sends strings to the wrapped stream as bytes using the given encoding.
 
     :param AnyByteSendStream transport_stream: any bytes-based send stream
-    :param str encoding: character encoding to use for encoding strings to bytes (defaults to
-        ``utf-8``)
-    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see the
-        `codecs module documentation`_ for a comprehensive list of options)
+    :param str encoding: character encoding to use for encoding strings to bytes
+        (defaults to ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
+        the `codecs module documentation`_ for a comprehensive list of options)
 
-    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
     """
 
     transport_stream: AnyByteSendStream
     encoding: InitVar[str] = "utf-8"
     errors: str = "strict"
-    _encoder: Callable[..., Tuple[bytes, int]] = field(init=False)
+    _encoder: Callable[..., tuple[bytes, int]] = field(init=False)
 
     def __post_init__(self, encoding: str) -> None:
         self._encoder = codecs.getencoder(encoding)
@@ -91,19 +96,20 @@ def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
 @dataclass(eq=False)
 class TextStream(ObjectStream[str]):
     """
-    A bidirectional stream that decodes bytes to strings on receive and encodes strings to bytes on
-    send.
+    A bidirectional stream that decodes bytes to strings on receive and encodes strings
+    to bytes on send.
 
-    Extra attributes will be provided from both streams, with the receive stream providing the
-    values in case of a conflict.
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
 
     :param AnyByteStream transport_stream: any bytes-based stream
-    :param str encoding: character encoding to use for encoding/decoding strings to/from bytes
-        (defaults to ``utf-8``)
-    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see the
-        `codecs module documentation`_ for a comprehensive list of options)
+    :param str encoding: character encoding to use for encoding/decoding strings to/from
+        bytes (defaults to ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
+        the `codecs module documentation`_ for a comprehensive list of options)
 
-    .. _codecs module documentation: https://docs.python.org/3/library/codecs.html#codec-objects
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
     """
 
     transport_stream: AnyByteStream
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/streams/tls.py b/addon/globalPlugins/spellcheck/libs/anyio/streams/tls.py
index 2cdee1d..e913eed 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/streams/tls.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/streams/tls.py
@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 import logging
 import re
 import ssl
+import sys
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, TypeVar, Union
+from typing import Any, Tuple, TypeVar
 
 from .. import (
     BrokenResourceError,
@@ -14,31 +18,40 @@
 from .._core._typedattr import TypedAttributeSet, typed_attribute
 from ..abc import AnyByteStream, ByteStream, Listener, TaskGroup
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
 T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+_PCTRTT = Tuple[Tuple[str, str], ...]
+_PCTRTTT = Tuple[_PCTRTT, ...]
 
 
 class TLSAttribute(TypedAttributeSet):
     """Contains Transport Layer Security related attributes."""
 
     #: the selected ALPN protocol
-    alpn_protocol: Optional[str] = typed_attribute()
+    alpn_protocol: str | None = typed_attribute()
     #: the channel binding for type ``tls-unique``
     channel_binding_tls_unique: bytes = typed_attribute()
     #: the selected cipher
-    cipher: Tuple[str, str, int] = typed_attribute()
-    #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert` for more
-    #: information)
-    peer_certificate: Optional[Dict[str, Union[str, tuple]]] = typed_attribute()
+    cipher: tuple[str, str, int] = typed_attribute()
+    #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert`
+    # for more information)
+    peer_certificate: None | (dict[str, str | _PCTRTTT | _PCTRTT]) = typed_attribute()
     #: the peer certificate in binary form
-    peer_certificate_binary: Optional[bytes] = typed_attribute()
+    peer_certificate_binary: bytes | None = typed_attribute()
     #: ``True`` if this is the server side of the connection
     server_side: bool = typed_attribute()
-    #: ciphers shared between both ends of the TLS connection
-    shared_ciphers: List[Tuple[str, str, int]] = typed_attribute()
+    #: ciphers shared by the client during the TLS handshake (``None`` if this is the
+    #: client side)
+    shared_ciphers: list[tuple[str, str, int]] | None = typed_attribute()
     #: the :class:`~ssl.SSLObject` used for encryption
     ssl_object: ssl.SSLObject = typed_attribute()
-    #: ``True`` if this stream does (and expects) a closing TLS handshake when the stream is being
-    #: closed
+    #: ``True`` if this stream does (and expects) a closing TLS handshake when the
+    #: stream is being closed
     standard_compatible: bool = typed_attribute()
     #: the TLS protocol version (e.g. ``TLSv1.2``)
     tls_version: str = typed_attribute()
@@ -67,26 +80,27 @@ async def wrap(
         cls,
         transport_stream: AnyByteStream,
         *,
-        server_side: Optional[bool] = None,
-        hostname: Optional[str] = None,
-        ssl_context: Optional[ssl.SSLContext] = None,
+        server_side: bool | None = None,
+        hostname: str | None = None,
+        ssl_context: ssl.SSLContext | None = None,
         standard_compatible: bool = True,
-    ) -> "TLSStream":
+    ) -> TLSStream:
         """
         Wrap an existing stream with Transport Layer Security.
 
         This performs a TLS handshake with the peer.
 
         :param transport_stream: a bytes-transporting stream to wrap
-        :param server_side: ``True`` if this is the server side of the connection, ``False`` if
-            this is the client side (if omitted, will be set to ``False`` if ``hostname`` has been
-            provided, ``False`` otherwise). Used only to create a default context when an explicit
-            context has not been provided.
+        :param server_side: ``True`` if this is the server side of the connection,
+            ``False`` if this is the client side (if omitted, will be set to ``False``
+            if ``hostname`` has been provided, ``False`` otherwise). Used only to create
+            a default context when an explicit context has not been provided.
         :param hostname: host name of the peer (if host name checking is desired)
-        :param ssl_context: the SSLContext object to use (if not provided, a secure default will be
-            created)
-        :param standard_compatible: if ``False``, skip the closing handshake when closing the
-            connection, and don't raise an exception if the peer does the same
+        :param ssl_context: the SSLContext object to use (if not provided, a secure
+            default will be created)
+        :param standard_compatible: if ``False``, skip the closing handshake when
+            closing the connection, and don't raise an exception if the peer does the
+            same
         :raises ~ssl.SSLError: if the TLS handshake fails
 
         """
@@ -99,6 +113,10 @@ async def wrap(
             )
             ssl_context = ssl.create_default_context(purpose)
 
+            # Re-enable detection of unexpected EOFs if it was disabled by Python
+            if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"):
+                ssl_context.options &= ~ssl.OP_IGNORE_UNEXPECTED_EOF
+
         bio_in = ssl.MemoryBIO()
         bio_out = ssl.MemoryBIO()
         ssl_object = ssl_context.wrap_bio(
@@ -115,7 +133,7 @@ async def wrap(
         return wrapper
 
     async def _call_sslobject_method(
-        self, func: Callable[..., T_Retval], *args: object
+        self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT]
     ) -> T_Retval:
         while True:
             try:
@@ -137,8 +155,23 @@ async def _call_sslobject_method(
                     self._read_bio.write(data)
             except ssl.SSLWantWriteError:
                 await self.transport_stream.send(self._write_bio.read())
-            except (ssl.SSLEOFError, ssl.SSLSyscallError) as exc:
+            except ssl.SSLSyscallError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
                 raise BrokenResourceError from exc
+            except ssl.SSLError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
+                if (
+                    isinstance(exc, ssl.SSLEOFError)
+                    or "UNEXPECTED_EOF_WHILE_READING" in exc.strerror
+                ):
+                    if self.standard_compatible:
+                        raise BrokenResourceError from exc
+                    else:
+                        raise EndOfStream from None
+
+                raise
             else:
                 # Flush any pending writes first
                 if self._write_bio.pending:
@@ -146,7 +179,7 @@ async def _call_sslobject_method(
 
                 return result
 
-    async def unwrap(self) -> Tuple[AnyByteStream, bytes]:
+    async def unwrap(self) -> tuple[AnyByteStream, bytes]:
         """
         Does the TLS closing handshake.
 
@@ -198,14 +231,18 @@ def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
         return {
             **self.transport_stream.extra_attributes,
             TLSAttribute.alpn_protocol: self._ssl_object.selected_alpn_protocol,
-            TLSAttribute.channel_binding_tls_unique: self._ssl_object.get_channel_binding,
+            TLSAttribute.channel_binding_tls_unique: (
+                self._ssl_object.get_channel_binding
+            ),
             TLSAttribute.cipher: self._ssl_object.cipher,
             TLSAttribute.peer_certificate: lambda: self._ssl_object.getpeercert(False),
             TLSAttribute.peer_certificate_binary: lambda: self._ssl_object.getpeercert(
                 True
             ),
             TLSAttribute.server_side: lambda: self._ssl_object.server_side,
-            TLSAttribute.shared_ciphers: lambda: self._ssl_object.shared_ciphers(),
+            TLSAttribute.shared_ciphers: lambda: self._ssl_object.shared_ciphers()
+            if self._ssl_object.server_side
+            else None,
             TLSAttribute.standard_compatible: lambda: self.standard_compatible,
             TLSAttribute.ssl_object: lambda: self._ssl_object,
             TLSAttribute.tls_version: self._ssl_object.version,
@@ -215,11 +252,12 @@ def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
 @dataclass(eq=False)
 class TLSListener(Listener[TLSStream]):
     """
-    A convenience listener that wraps another listener and auto-negotiates a TLS session on every
-    accepted connection.
+    A convenience listener that wraps another listener and auto-negotiates a TLS session
+    on every accepted connection.
 
-    If the TLS handshake times out or raises an exception, :meth:`handle_handshake_error` is
-    called to do whatever post-mortem processing is deemed necessary.
+    If the TLS handshake times out or raises an exception,
+    :meth:`handle_handshake_error` is called to do whatever post-mortem processing is
+    deemed necessary.
 
     Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute.
 
@@ -230,21 +268,21 @@ class TLSListener(Listener[TLSStream]):
         (passed to :func:`~anyio.fail_after`)
     """
 
-    listener: Listener
+    listener: Listener[Any]
     ssl_context: ssl.SSLContext
     standard_compatible: bool = True
     handshake_timeout: float = 30
 
     @staticmethod
     async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> None:
-        f"""
+        """
         Handle an exception raised during the TLS handshake.
 
         This method does 3 things:
 
         #. Forcefully closes the original stream
-        #. Logs the exception (unless it was a cancellation exception) using the ``{__name__}``
-           logger
+        #. Logs the exception (unless it was a cancellation exception) using the
+           ``anyio.streams.tls`` logger
         #. Reraises the exception if it was a base exception or a cancellation exception
 
         :param exc: the exception
@@ -255,7 +293,13 @@ async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> N
 
         # Log all except cancellation exceptions
         if not isinstance(exc, get_cancelled_exc_class()):
-            logging.getLogger(__name__).exception("Error during TLS handshake")
+            # CPython (as of 3.11.5) returns incorrect `sys.exc_info()` here when using
+            # any asyncio implementation, so we explicitly pass the exception to log
+            # (https://github.com/python/cpython/issues/108668). Trio does not have this
+            # issue because it works around the CPython bug.
+            logging.getLogger(__name__).exception(
+                "Error during TLS handshake", exc_info=exc
+            )
 
         # Only reraise base exceptions and cancellation exceptions
         if not isinstance(exc, Exception) or isinstance(exc, get_cancelled_exc_class()):
@@ -264,7 +308,7 @@ async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> N
     async def serve(
         self,
         handler: Callable[[TLSStream], Any],
-        task_group: Optional[TaskGroup] = None,
+        task_group: TaskGroup | None = None,
     ) -> None:
         @wraps(handler)
         async def handler_wrapper(stream: AnyByteStream) -> None:
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/to_process.py b/addon/globalPlugins/spellcheck/libs/anyio/to_process.py
index 85671c4..1ff06f0 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/to_process.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/to_process.py
@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 import os
 import pickle
 import subprocess
 import sys
 from collections import deque
-from importlib.abc import Loader
+from collections.abc import Callable
 from importlib.util import module_from_spec, spec_from_file_location
-from typing import Callable, Deque, List, Optional, Set, Tuple, TypeVar, cast
+from typing import TypeVar, cast
 
-from ._core._eventloop import current_time, get_asynclib, get_cancelled_exc_class
+from ._core._eventloop import current_time, get_async_backend, get_cancelled_exc_class
 from ._core._exceptions import BrokenWorkerProcess
 from ._core._subprocesses import open_process
 from ._core._synchronization import CapacityLimiter
@@ -16,34 +18,42 @@
 from .lowlevel import RunVar, checkpoint_if_cancelled
 from .streams.buffered import BufferedByteReceiveStream
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
 WORKER_MAX_IDLE_TIME = 300  # 5 minutes
 
 T_Retval = TypeVar("T_Retval")
-_process_pool_workers: RunVar[Set[Process]] = RunVar("_process_pool_workers")
-_process_pool_idle_workers: RunVar[Deque[Tuple[Process, float]]] = RunVar(
+PosArgsT = TypeVarTuple("PosArgsT")
+
+_process_pool_workers: RunVar[set[Process]] = RunVar("_process_pool_workers")
+_process_pool_idle_workers: RunVar[deque[tuple[Process, float]]] = RunVar(
     "_process_pool_idle_workers"
 )
 _default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter")
 
 
 async def run_sync(
-    func: Callable[..., T_Retval],
-    *args: object,
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
     cancellable: bool = False,
-    limiter: Optional[CapacityLimiter] = None,
+    limiter: CapacityLimiter | None = None,
 ) -> T_Retval:
     """
     Call the given function with the given arguments in a worker process.
 
-    If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
-    the worker process running it will be abruptly terminated using SIGKILL (or
-    ``terminateProcess()`` on Windows).
+    If the ``cancellable`` option is enabled and the task waiting for its completion is
+    cancelled, the worker process running it will be abruptly terminated using SIGKILL
+    (or ``terminateProcess()`` on Windows).
 
     :param func: a callable
     :param args: positional arguments for the callable
-    :param cancellable: ``True`` to allow cancellation of the operation while it's running
-    :param limiter: capacity limiter to use to limit the total amount of processes running
-        (if omitted, the default limiter is used)
+    :param cancellable: ``True`` to allow cancellation of the operation while it's
+        running
+    :param limiter: capacity limiter to use to limit the total amount of processes
+        running (if omitted, the default limiter is used)
     :return: an awaitable that yields the return value of the function.
 
     """
@@ -93,11 +103,11 @@ async def send_raw_command(pickled_cmd: bytes) -> object:
         idle_workers = deque()
         _process_pool_workers.set(workers)
         _process_pool_idle_workers.set(idle_workers)
-        get_asynclib().setup_process_pool_exit_at_shutdown(workers)
+        get_async_backend().setup_process_pool_exit_at_shutdown(workers)
 
-    async with (limiter or current_default_process_limiter()):
-        # Pop processes from the pool (starting from the most recently used) until we find one that
-        # hasn't exited yet
+    async with limiter or current_default_process_limiter():
+        # Pop processes from the pool (starting from the most recently used) until we
+        # find one that hasn't exited yet
         process: Process
         while idle_workers:
             process, idle_since = idle_workers.pop()
@@ -107,22 +117,22 @@ async def send_raw_command(pickled_cmd: bytes) -> object:
                     cast(ByteReceiveStream, process.stdout)
                 )
 
-                # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME seconds or
-                # longer
+                # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME
+                # seconds or longer
                 now = current_time()
-                killed_processes: List[Process] = []
+                killed_processes: list[Process] = []
                 while idle_workers:
                     if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME:
                         break
 
-                    process, idle_since = idle_workers.popleft()
-                    process.kill()
-                    workers.remove(process)
-                    killed_processes.append(process)
+                    process_to_kill, idle_since = idle_workers.popleft()
+                    process_to_kill.kill()
+                    workers.remove(process_to_kill)
+                    killed_processes.append(process_to_kill)
 
                 with CancelScope(shield=True):
-                    for process in killed_processes:
-                        await process.aclose()
+                    for killed_process in killed_processes:
+                        await killed_process.aclose()
 
                 break
 
@@ -171,7 +181,8 @@ async def send_raw_command(pickled_cmd: bytes) -> object:
 
 def current_default_process_limiter() -> CapacityLimiter:
     """
-    Return the capacity limiter that is used by default to limit the number of worker processes.
+    Return the capacity limiter that is used by default to limit the number of worker
+    processes.
 
     :return: a capacity limiter object
 
@@ -209,17 +220,17 @@ def process_worker() -> None:
                 except BaseException as exc:
                     exception = exc
             elif command == "init":
-                main_module_path: Optional[str]
+                main_module_path: str | None
                 sys.path, main_module_path = args
                 del sys.modules["__main__"]
                 if main_module_path:
-                    # Load the parent's main module but as __mp_main__ instead of __main__
-                    # (like multiprocessing does) to avoid infinite recursion
+                    # Load the parent's main module but as __mp_main__ instead of
+                    # __main__ (like multiprocessing does) to avoid infinite recursion
                     try:
                         spec = spec_from_file_location("__mp_main__", main_module_path)
                         if spec and spec.loader:
                             main = module_from_spec(spec)
-                            cast(Loader, spec.loader).exec_module(main)
+                            spec.loader.exec_module(main)
                             sys.modules["__main__"] = main
                     except BaseException as exc:
                         exception = exc
diff --git a/addon/globalPlugins/spellcheck/libs/anyio/to_thread.py b/addon/globalPlugins/spellcheck/libs/anyio/to_thread.py
index a2fd42f..5070516 100644
--- a/addon/globalPlugins/spellcheck/libs/anyio/to_thread.py
+++ b/addon/globalPlugins/spellcheck/libs/anyio/to_thread.py
@@ -1,65 +1,69 @@
-from typing import Callable, Optional, TypeVar
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from typing import TypeVar
 from warnings import warn
 
-from ._core._eventloop import get_asynclib
+from ._core._eventloop import get_async_backend
 from .abc import CapacityLimiter
 
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
 T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
 
 
 async def run_sync(
-    func: Callable[..., T_Retval],
-    *args: object,
-    cancellable: bool = False,
-    limiter: Optional[CapacityLimiter] = None
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
+    abandon_on_cancel: bool = False,
+    cancellable: bool | None = None,
+    limiter: CapacityLimiter | None = None,
 ) -> T_Retval:
     """
     Call the given function with the given arguments in a worker thread.
 
-    If the ``cancellable`` option is enabled and the task waiting for its completion is cancelled,
-    the thread will still run its course but its return value (or any raised exception) will be
-    ignored.
+    If the ``cancellable`` option is enabled and the task waiting for its completion is
+    cancelled, the thread will still run its course but its return value (or any raised
+    exception) will be ignored.
 
     :param func: a callable
     :param args: positional arguments for the callable
-    :param cancellable: ``True`` to allow cancellation of the operation
+    :param abandon_on_cancel: ``True`` to abandon the thread (leaving it to run
+        unchecked on own) if the host task is cancelled, ``False`` to ignore
+        cancellations in the host task until the operation has completed in the worker
+        thread
+    :param cancellable: deprecated alias of ``abandon_on_cancel``; will override
+        ``abandon_on_cancel`` if both parameters are passed
     :param limiter: capacity limiter to use to limit the total amount of threads running
         (if omitted, the default limiter is used)
     :return: an awaitable that yields the return value of the function.
 
     """
-    return await get_asynclib().run_sync_in_worker_thread(
-        func, *args, cancellable=cancellable, limiter=limiter
-    )
-
+    if cancellable is not None:
+        abandon_on_cancel = cancellable
+        warn(
+            "The `cancellable=` keyword argument to `anyio.to_thread.run_sync` is "
+            "deprecated since AnyIO 4.1.0; use `abandon_on_cancel=` instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
-async def run_sync_in_worker_thread(
-    func: Callable[..., T_Retval],
-    *args: object,
-    cancellable: bool = False,
-    limiter: Optional[CapacityLimiter] = None
-) -> T_Retval:
-    warn(
-        "run_sync_in_worker_thread() has been deprecated, use anyio.to_thread.run_sync() instead",
-        DeprecationWarning,
+    return await get_async_backend().run_sync_in_worker_thread(
+        func, args, abandon_on_cancel=abandon_on_cancel, limiter=limiter
     )
-    return await run_sync(func, *args, cancellable=cancellable, limiter=limiter)
 
 
 def current_default_thread_limiter() -> CapacityLimiter:
     """
-    Return the capacity limiter that is used by default to limit the number of concurrent threads.
+    Return the capacity limiter that is used by default to limit the number of
+    concurrent threads.
 
     :return: a capacity limiter object
 
     """
-    return get_asynclib().current_default_thread_limiter()
-
-
-def current_default_worker_thread_limiter() -> CapacityLimiter:
-    warn(
-        "current_default_worker_thread_limiter() has been deprecated, "
-        "use anyio.to_thread.current_default_thread_limiter() instead",
-        DeprecationWarning,
-    )
-    return current_default_thread_limiter()
+    return get_async_backend().current_default_thread_limiter()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/__init__.py b/addon/globalPlugins/spellcheck/libs/asyncio/__init__.py
deleted file mode 100644
index 4cb3c34..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/__init__.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""The asyncio package, tracking PEP 3156."""
-
-# flake8: noqa
-
-import sys
-
-# This relies on each of the submodules having an __all__ variable.
-from .base_events import *
-from .coroutines import *
-from .events import *
-from .futures import *
-from .locks import *
-from .protocols import *
-from .runners import *
-from .queues import *
-from .streams import *
-from .subprocess import *
-from .tasks import *
-from .transports import *
-
-# Exposed for _asynciomodule.c to implement now deprecated
-# Task.all_tasks() method.  This function will be removed in 3.9.
-from .tasks import _all_tasks_compat  # NoQA
-
-__all__ = (
-    base_events.__all__
-    + coroutines.__all__
-    + events.__all__
-    + futures.__all__
-    + locks.__all__
-    + protocols.__all__
-    + runners.__all__
-    + queues.__all__
-    + streams.__all__
-    + subprocess.__all__
-    + tasks.__all__
-    + transports.__all__
-)
-
-if sys.platform == "win32":  # pragma: no cover
-    from .windows_events import *
-
-    __all__ += windows_events.__all__
-else:
-    from .unix_events import *  # pragma: no cover
-
-    __all__ += unix_events.__all__
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/base_events.py b/addon/globalPlugins/spellcheck/libs/asyncio/base_events.py
deleted file mode 100644
index 7f23f9d..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/base_events.py
+++ /dev/null
@@ -1,1985 +0,0 @@
-"""Base implementation of event loop.
-
-The event loop can be broken up into a multiplexer (the part
-responsible for notifying us of I/O events) and the event loop proper,
-which wraps a multiplexer with functionality for scheduling callbacks,
-immediately or at a given time in the future.
-
-Whenever a public API takes a callback, subsequent positional
-arguments will be passed to the callback if/when it is called.  This
-avoids the proliferation of trivial lambdas implementing closures.
-Keyword arguments for the callback are not supported; this is a
-conscious design decision, leaving the door open for keyword arguments
-to modify the meaning of the API call itself.
-"""
-
-import collections
-import collections.abc
-import concurrent.futures
-import heapq
-import itertools
-import logging
-import os
-import socket
-import subprocess
-import threading
-import time
-import traceback
-import sys
-import warnings
-import weakref
-
-try:
-    import ssl
-except ImportError:  # pragma: no cover
-    ssl = None
-
-from . import constants
-from . import coroutines
-from . import events
-from . import futures
-from . import protocols
-from . import sslproto
-from . import tasks
-from . import transports
-from .log import logger
-
-
-__all__ = ("BaseEventLoop",)
-
-
-# Minimum number of _scheduled timer handles before cleanup of
-# cancelled handles is performed.
-_MIN_SCHEDULED_TIMER_HANDLES = 100
-
-# Minimum fraction of _scheduled timer handles that are cancelled
-# before cleanup of cancelled handles is performed.
-_MIN_CANCELLED_TIMER_HANDLES_FRACTION = 0.5
-
-_HAS_IPv6 = hasattr(socket, "AF_INET6")
-
-# Maximum timeout passed to select to avoid OS limitations
-MAXIMUM_SELECT_TIMEOUT = 24 * 3600
-
-# Used for deprecation and removal of `loop.create_datagram_endpoint()`'s
-# *reuse_address* parameter
-_unset = object()
-
-
-def _format_handle(handle):
-    cb = handle._callback
-    if isinstance(getattr(cb, "__self__", None), tasks.Task):
-        # format the task
-        return repr(cb.__self__)
-    else:
-        return str(handle)
-
-
-def _format_pipe(fd):
-    if fd == subprocess.PIPE:
-        return "<pipe>"
-    elif fd == subprocess.STDOUT:
-        return "<stdout>"
-    else:
-        return repr(fd)
-
-
-def _set_reuseport(sock):
-    if not hasattr(socket, "SO_REUSEPORT"):
-        raise ValueError("reuse_port not supported by socket module")
-    else:
-        try:
-            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-        except OSError:
-            raise ValueError(
-                "reuse_port not supported by socket module, "
-                "SO_REUSEPORT defined but not implemented."
-            )
-
-
-def _ipaddr_info(host, port, family, type, proto, flowinfo=0, scopeid=0):
-    # Try to skip getaddrinfo if "host" is already an IP. Users might have
-    # handled name resolution in their own code and pass in resolved IPs.
-    if not hasattr(socket, "inet_pton"):
-        return
-
-    if proto not in {0, socket.IPPROTO_TCP, socket.IPPROTO_UDP} or host is None:
-        return None
-
-    if type == socket.SOCK_STREAM:
-        proto = socket.IPPROTO_TCP
-    elif type == socket.SOCK_DGRAM:
-        proto = socket.IPPROTO_UDP
-    else:
-        return None
-
-    if port is None:
-        port = 0
-    elif isinstance(port, bytes) and port == b"":
-        port = 0
-    elif isinstance(port, str) and port == "":
-        port = 0
-    else:
-        # If port's a service name like "http", don't skip getaddrinfo.
-        try:
-            port = int(port)
-        except (TypeError, ValueError):
-            return None
-
-    if family == socket.AF_UNSPEC:
-        afs = [socket.AF_INET]
-        if _HAS_IPv6:
-            afs.append(socket.AF_INET6)
-    else:
-        afs = [family]
-
-    if isinstance(host, bytes):
-        host = host.decode("idna")
-    if "%" in host:
-        # Linux's inet_pton doesn't accept an IPv6 zone index after host,
-        # like '::1%lo0'.
-        return None
-
-    for af in afs:
-        try:
-            socket.inet_pton(af, host)
-            # The host has already been resolved.
-            if _HAS_IPv6 and af == socket.AF_INET6:
-                return af, type, proto, "", (host, port, flowinfo, scopeid)
-            else:
-                return af, type, proto, "", (host, port)
-        except OSError:
-            pass
-
-    # "host" is not an IP address.
-    return None
-
-
-def _run_until_complete_cb(fut):
-    if not fut.cancelled():
-        exc = fut.exception()
-        if isinstance(exc, BaseException) and not isinstance(exc, Exception):
-            # Issue #22429: run_forever() already finished, no need to
-            # stop it.
-            return
-    futures._get_loop(fut).stop()
-
-
-if hasattr(socket, "TCP_NODELAY"):
-
-    def _set_nodelay(sock):
-        if (
-            sock.family in {socket.AF_INET, socket.AF_INET6}
-            and sock.type == socket.SOCK_STREAM
-            and sock.proto == socket.IPPROTO_TCP
-        ):
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-
-
-else:
-
-    def _set_nodelay(sock):
-        pass
-
-
-class _SendfileFallbackProtocol(protocols.Protocol):
-    def __init__(self, transp):
-        if not isinstance(transp, transports._FlowControlMixin):
-            raise TypeError("transport should be _FlowControlMixin instance")
-        self._transport = transp
-        self._proto = transp.get_protocol()
-        self._should_resume_reading = transp.is_reading()
-        self._should_resume_writing = transp._protocol_paused
-        transp.pause_reading()
-        transp.set_protocol(self)
-        if self._should_resume_writing:
-            self._write_ready_fut = self._transport._loop.create_future()
-        else:
-            self._write_ready_fut = None
-
-    async def drain(self):
-        if self._transport.is_closing():
-            raise ConnectionError("Connection closed by peer")
-        fut = self._write_ready_fut
-        if fut is None:
-            return
-        await fut
-
-    def connection_made(self, transport):
-        raise RuntimeError(
-            "Invalid state: " "connection should have been established already."
-        )
-
-    def connection_lost(self, exc):
-        if self._write_ready_fut is not None:
-            # Never happens if peer disconnects after sending the whole content
-            # Thus disconnection is always an exception from user perspective
-            if exc is None:
-                self._write_ready_fut.set_exception(
-                    ConnectionError("Connection is closed by peer")
-                )
-            else:
-                self._write_ready_fut.set_exception(exc)
-        self._proto.connection_lost(exc)
-
-    def pause_writing(self):
-        if self._write_ready_fut is not None:
-            return
-        self._write_ready_fut = self._transport._loop.create_future()
-
-    def resume_writing(self):
-        if self._write_ready_fut is None:
-            return
-        self._write_ready_fut.set_result(False)
-        self._write_ready_fut = None
-
-    def data_received(self, data):
-        raise RuntimeError("Invalid state: reading should be paused")
-
-    def eof_received(self):
-        raise RuntimeError("Invalid state: reading should be paused")
-
-    async def restore(self):
-        self._transport.set_protocol(self._proto)
-        if self._should_resume_reading:
-            self._transport.resume_reading()
-        if self._write_ready_fut is not None:
-            # Cancel the future.
-            # Basically it has no effect because protocol is switched back,
-            # no code should wait for it anymore.
-            self._write_ready_fut.cancel()
-        if self._should_resume_writing:
-            self._proto.resume_writing()
-
-
-class Server(events.AbstractServer):
-    def __init__(
-        self,
-        loop,
-        sockets,
-        protocol_factory,
-        ssl_context,
-        backlog,
-        ssl_handshake_timeout,
-    ):
-        self._loop = loop
-        self._sockets = sockets
-        self._active_count = 0
-        self._waiters = []
-        self._protocol_factory = protocol_factory
-        self._backlog = backlog
-        self._ssl_context = ssl_context
-        self._ssl_handshake_timeout = ssl_handshake_timeout
-        self._serving = False
-        self._serving_forever_fut = None
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__} sockets={self.sockets!r}>"
-
-    def _attach(self):
-        assert self._sockets is not None
-        self._active_count += 1
-
-    def _detach(self):
-        assert self._active_count > 0
-        self._active_count -= 1
-        if self._active_count == 0 and self._sockets is None:
-            self._wakeup()
-
-    def _wakeup(self):
-        waiters = self._waiters
-        self._waiters = None
-        for waiter in waiters:
-            if not waiter.done():
-                waiter.set_result(waiter)
-
-    def _start_serving(self):
-        if self._serving:
-            return
-        self._serving = True
-        for sock in self._sockets:
-            sock.listen(self._backlog)
-            self._loop._start_serving(
-                self._protocol_factory,
-                sock,
-                self._ssl_context,
-                self,
-                self._backlog,
-                self._ssl_handshake_timeout,
-            )
-
-    def get_loop(self):
-        return self._loop
-
-    def is_serving(self):
-        return self._serving
-
-    @property
-    def sockets(self):
-        if self._sockets is None:
-            return []
-        return list(self._sockets)
-
-    def close(self):
-        sockets = self._sockets
-        if sockets is None:
-            return
-        self._sockets = None
-
-        for sock in sockets:
-            self._loop._stop_serving(sock)
-
-        self._serving = False
-
-        if (
-            self._serving_forever_fut is not None
-            and not self._serving_forever_fut.done()
-        ):
-            self._serving_forever_fut.cancel()
-            self._serving_forever_fut = None
-
-        if self._active_count == 0:
-            self._wakeup()
-
-    async def start_serving(self):
-        self._start_serving()
-        # Skip one loop iteration so that all 'loop.add_reader'
-        # go through.
-        await tasks.sleep(0, loop=self._loop)
-
-    async def serve_forever(self):
-        if self._serving_forever_fut is not None:
-            raise RuntimeError(
-                f"server {self!r} is already being awaited on serve_forever()"
-            )
-        if self._sockets is None:
-            raise RuntimeError(f"server {self!r} is closed")
-
-        self._start_serving()
-        self._serving_forever_fut = self._loop.create_future()
-
-        try:
-            await self._serving_forever_fut
-        except futures.CancelledError:
-            try:
-                self.close()
-                await self.wait_closed()
-            finally:
-                raise
-        finally:
-            self._serving_forever_fut = None
-
-    async def wait_closed(self):
-        if self._sockets is None or self._waiters is None:
-            return
-        waiter = self._loop.create_future()
-        self._waiters.append(waiter)
-        await waiter
-
-
-class BaseEventLoop(events.AbstractEventLoop):
-    def __init__(self):
-        self._timer_cancelled_count = 0
-        self._closed = False
-        self._stopping = False
-        self._ready = collections.deque()
-        self._scheduled = []
-        self._default_executor = None
-        self._internal_fds = 0
-        # Identifier of the thread running the event loop, or None if the
-        # event loop is not running
-        self._thread_id = None
-        self._clock_resolution = time.get_clock_info("monotonic").resolution
-        self._exception_handler = None
-        self.set_debug(coroutines._is_debug_mode())
-        # In debug mode, if the execution of a callback or a step of a task
-        # exceed this duration in seconds, the slow callback/task is logged.
-        self.slow_callback_duration = 0.1
-        self._current_handle = None
-        self._task_factory = None
-        self._coroutine_origin_tracking_enabled = False
-        self._coroutine_origin_tracking_saved_depth = None
-
-        # A weak set of all asynchronous generators that are
-        # being iterated by the loop.
-        self._asyncgens = weakref.WeakSet()
-        # Set to True when `loop.shutdown_asyncgens` is called.
-        self._asyncgens_shutdown_called = False
-
-    def __repr__(self):
-        return (
-            f"<{self.__class__.__name__} running={self.is_running()} "
-            f"closed={self.is_closed()} debug={self.get_debug()}>"
-        )
-
-    def create_future(self):
-        """Create a Future object attached to the loop."""
-        return futures.Future(loop=self)
-
-    def create_task(self, coro):
-        """Schedule a coroutine object.
-
-        Return a task object.
-        """
-        self._check_closed()
-        if self._task_factory is None:
-            task = tasks.Task(coro, loop=self)
-            if task._source_traceback:
-                del task._source_traceback[-1]
-        else:
-            task = self._task_factory(self, coro)
-        return task
-
-    def set_task_factory(self, factory):
-        """Set a task factory that will be used by loop.create_task().
-
-        If factory is None the default task factory will be set.
-
-        If factory is a callable, it should have a signature matching
-        '(loop, coro)', where 'loop' will be a reference to the active
-        event loop, 'coro' will be a coroutine object.  The callable
-        must return a Future.
-        """
-        if factory is not None and not callable(factory):
-            raise TypeError("task factory must be a callable or None")
-        self._task_factory = factory
-
-    def get_task_factory(self):
-        """Return a task factory, or None if the default one is in use."""
-        return self._task_factory
-
-    def _make_socket_transport(
-        self, sock, protocol, waiter=None, *, extra=None, server=None
-    ):
-        """Create socket transport."""
-        raise NotImplementedError
-
-    def _make_ssl_transport(
-        self,
-        rawsock,
-        protocol,
-        sslcontext,
-        waiter=None,
-        *,
-        server_side=False,
-        server_hostname=None,
-        extra=None,
-        server=None,
-        ssl_handshake_timeout=None,
-        call_connection_made=True,
-    ):
-        """Create SSL transport."""
-        raise NotImplementedError
-
-    def _make_datagram_transport(
-        self, sock, protocol, address=None, waiter=None, extra=None
-    ):
-        """Create datagram transport."""
-        raise NotImplementedError
-
-    def _make_read_pipe_transport(self, pipe, protocol, waiter=None, extra=None):
-        """Create read pipe transport."""
-        raise NotImplementedError
-
-    def _make_write_pipe_transport(self, pipe, protocol, waiter=None, extra=None):
-        """Create write pipe transport."""
-        raise NotImplementedError
-
-    async def _make_subprocess_transport(
-        self,
-        protocol,
-        args,
-        shell,
-        stdin,
-        stdout,
-        stderr,
-        bufsize,
-        extra=None,
-        **kwargs,
-    ):
-        """Create subprocess transport."""
-        raise NotImplementedError
-
-    def _write_to_self(self):
-        """Write a byte to self-pipe, to wake up the event loop.
-
-        This may be called from a different thread.
-
-        The subclass is responsible for implementing the self-pipe.
-        """
-        raise NotImplementedError
-
-    def _process_events(self, event_list):
-        """Process selector events."""
-        raise NotImplementedError
-
-    def _check_closed(self):
-        if self._closed:
-            raise RuntimeError("Event loop is closed")
-
-    def _asyncgen_finalizer_hook(self, agen):
-        self._asyncgens.discard(agen)
-        if not self.is_closed():
-            self.call_soon_threadsafe(self.create_task, agen.aclose())
-
-    def _asyncgen_firstiter_hook(self, agen):
-        if self._asyncgens_shutdown_called:
-            warnings.warn(
-                f"asynchronous generator {agen!r} was scheduled after "
-                f"loop.shutdown_asyncgens() call",
-                ResourceWarning,
-                source=self,
-            )
-
-        self._asyncgens.add(agen)
-
-    async def shutdown_asyncgens(self):
-        """Shutdown all active asynchronous generators."""
-        self._asyncgens_shutdown_called = True
-
-        if not len(self._asyncgens):
-            # If Python version is <3.6 or we don't have any asynchronous
-            # generators alive.
-            return
-
-        closing_agens = list(self._asyncgens)
-        self._asyncgens.clear()
-
-        results = await tasks.gather(
-            *[ag.aclose() for ag in closing_agens], return_exceptions=True, loop=self
-        )
-
-        for result, agen in zip(results, closing_agens):
-            if isinstance(result, Exception):
-                self.call_exception_handler(
-                    {
-                        "message": f"an error occurred during closing of "
-                        f"asynchronous generator {agen!r}",
-                        "exception": result,
-                        "asyncgen": agen,
-                    }
-                )
-
-    def _check_runnung(self):
-        if self.is_running():
-            raise RuntimeError("This event loop is already running")
-        if events._get_running_loop() is not None:
-            raise RuntimeError(
-                "Cannot run the event loop while another loop is running"
-            )
-
-    def run_forever(self):
-        """Run until stop() is called."""
-        self._check_closed()
-        self._check_runnung()
-        self._set_coroutine_origin_tracking(self._debug)
-        self._thread_id = threading.get_ident()
-
-        old_agen_hooks = sys.get_asyncgen_hooks()
-        sys.set_asyncgen_hooks(
-            firstiter=self._asyncgen_firstiter_hook,
-            finalizer=self._asyncgen_finalizer_hook,
-        )
-        try:
-            events._set_running_loop(self)
-            while True:
-                self._run_once()
-                if self._stopping:
-                    break
-        finally:
-            self._stopping = False
-            self._thread_id = None
-            events._set_running_loop(None)
-            self._set_coroutine_origin_tracking(False)
-            sys.set_asyncgen_hooks(*old_agen_hooks)
-
-    def run_until_complete(self, future):
-        """Run until the Future is done.
-
-        If the argument is a coroutine, it is wrapped in a Task.
-
-        WARNING: It would be disastrous to call run_until_complete()
-        with the same coroutine twice -- it would wrap it in two
-        different Tasks and that can't be good.
-
-        Return the Future's result, or raise its exception.
-        """
-        self._check_closed()
-        self._check_runnung()
-
-        new_task = not futures.isfuture(future)
-        future = tasks.ensure_future(future, loop=self)
-        if new_task:
-            # An exception is raised if the future didn't complete, so there
-            # is no need to log the "destroy pending task" message
-            future._log_destroy_pending = False
-
-        future.add_done_callback(_run_until_complete_cb)
-        try:
-            self.run_forever()
-        except:
-            if new_task and future.done() and not future.cancelled():
-                # The coroutine raised a BaseException. Consume the exception
-                # to not log a warning, the caller doesn't have access to the
-                # local task.
-                future.exception()
-            raise
-        finally:
-            future.remove_done_callback(_run_until_complete_cb)
-        if not future.done():
-            raise RuntimeError("Event loop stopped before Future completed.")
-
-        return future.result()
-
-    def stop(self):
-        """Stop running the event loop.
-
-        Every callback already scheduled will still run.  This simply informs
-        run_forever to stop looping after a complete iteration.
-        """
-        self._stopping = True
-
-    def close(self):
-        """Close the event loop.
-
-        This clears the queues and shuts down the executor,
-        but does not wait for the executor to finish.
-
-        The event loop must not be running.
-        """
-        if self.is_running():
-            raise RuntimeError("Cannot close a running event loop")
-        if self._closed:
-            return
-        if self._debug:
-            logger.debug("Close %r", self)
-        self._closed = True
-        self._ready.clear()
-        self._scheduled.clear()
-        executor = self._default_executor
-        if executor is not None:
-            self._default_executor = None
-            executor.shutdown(wait=False)
-
-    def is_closed(self):
-        """Returns True if the event loop was closed."""
-        return self._closed
-
-    def __del__(self):
-        if not self.is_closed():
-            warnings.warn(f"unclosed event loop {self!r}", ResourceWarning, source=self)
-            if not self.is_running():
-                self.close()
-
-    def is_running(self):
-        """Returns True if the event loop is running."""
-        return self._thread_id is not None
-
-    def time(self):
-        """Return the time according to the event loop's clock.
-
-        This is a float expressed in seconds since an epoch, but the
-        epoch, precision, accuracy and drift are unspecified and may
-        differ per event loop.
-        """
-        return time.monotonic()
-
-    def call_later(self, delay, callback, *args, context=None):
-        """Arrange for a callback to be called at a given time.
-
-        Return a Handle: an opaque object with a cancel() method that
-        can be used to cancel the call.
-
-        The delay can be an int or float, expressed in seconds.  It is
-        always relative to the current time.
-
-        Each callback will be called exactly once.  If two callbacks
-        are scheduled for exactly the same time, it undefined which
-        will be called first.
-
-        Any positional arguments after the callback will be passed to
-        the callback when it is called.
-        """
-        timer = self.call_at(self.time() + delay, callback, *args, context=context)
-        if timer._source_traceback:
-            del timer._source_traceback[-1]
-        return timer
-
-    def call_at(self, when, callback, *args, context=None):
-        """Like call_later(), but uses an absolute time.
-
-        Absolute time corresponds to the event loop's time() method.
-        """
-        self._check_closed()
-        if self._debug:
-            self._check_thread()
-            self._check_callback(callback, "call_at")
-        timer = events.TimerHandle(when, callback, args, self, context)
-        if timer._source_traceback:
-            del timer._source_traceback[-1]
-        heapq.heappush(self._scheduled, timer)
-        timer._scheduled = True
-        return timer
-
-    def call_soon(self, callback, *args, context=None):
-        """Arrange for a callback to be called as soon as possible.
-
-        This operates as a FIFO queue: callbacks are called in the
-        order in which they are registered.  Each callback will be
-        called exactly once.
-
-        Any positional arguments after the callback will be passed to
-        the callback when it is called.
-        """
-        self._check_closed()
-        if self._debug:
-            self._check_thread()
-            self._check_callback(callback, "call_soon")
-        handle = self._call_soon(callback, args, context)
-        if handle._source_traceback:
-            del handle._source_traceback[-1]
-        return handle
-
-    def _check_callback(self, callback, method):
-        if coroutines.iscoroutine(callback) or coroutines.iscoroutinefunction(callback):
-            raise TypeError(f"coroutines cannot be used with {method}()")
-        if not callable(callback):
-            raise TypeError(
-                f"a callable object was expected by {method}(), " f"got {callback!r}"
-            )
-
-    def _call_soon(self, callback, args, context):
-        handle = events.Handle(callback, args, self, context)
-        if handle._source_traceback:
-            del handle._source_traceback[-1]
-        self._ready.append(handle)
-        return handle
-
-    def _check_thread(self):
-        """Check that the current thread is the thread running the event loop.
-
-        Non-thread-safe methods of this class make this assumption and will
-        likely behave incorrectly when the assumption is violated.
-
-        Should only be called when (self._debug == True).  The caller is
-        responsible for checking this condition for performance reasons.
-        """
-        if self._thread_id is None:
-            return
-        thread_id = threading.get_ident()
-        if thread_id != self._thread_id:
-            raise RuntimeError(
-                "Non-thread-safe operation invoked on an event loop other "
-                "than the current one"
-            )
-
-    def call_soon_threadsafe(self, callback, *args, context=None):
-        """Like call_soon(), but thread-safe."""
-        self._check_closed()
-        if self._debug:
-            self._check_callback(callback, "call_soon_threadsafe")
-        handle = self._call_soon(callback, args, context)
-        if handle._source_traceback:
-            del handle._source_traceback[-1]
-        self._write_to_self()
-        return handle
-
-    def run_in_executor(self, executor, func, *args):
-        self._check_closed()
-        if self._debug:
-            self._check_callback(func, "run_in_executor")
-        if executor is None:
-            executor = self._default_executor
-            if executor is None:
-                executor = concurrent.futures.ThreadPoolExecutor()
-                self._default_executor = executor
-        return futures.wrap_future(executor.submit(func, *args), loop=self)
-
-    def set_default_executor(self, executor):
-        self._default_executor = executor
-
-    def _getaddrinfo_debug(self, host, port, family, type, proto, flags):
-        msg = [f"{host}:{port!r}"]
-        if family:
-            msg.append(f"family={family!r}")
-        if type:
-            msg.append(f"type={type!r}")
-        if proto:
-            msg.append(f"proto={proto!r}")
-        if flags:
-            msg.append(f"flags={flags!r}")
-        msg = ", ".join(msg)
-        logger.debug("Get address info %s", msg)
-
-        t0 = self.time()
-        addrinfo = socket.getaddrinfo(host, port, family, type, proto, flags)
-        dt = self.time() - t0
-
-        msg = f"Getting address info {msg} took {dt * 1e3:.3f}ms: {addrinfo!r}"
-        if dt >= self.slow_callback_duration:
-            logger.info(msg)
-        else:
-            logger.debug(msg)
-        return addrinfo
-
-    async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
-        if self._debug:
-            getaddr_func = self._getaddrinfo_debug
-        else:
-            getaddr_func = socket.getaddrinfo
-
-        return await self.run_in_executor(
-            None, getaddr_func, host, port, family, type, proto, flags
-        )
-
-    async def getnameinfo(self, sockaddr, flags=0):
-        return await self.run_in_executor(None, socket.getnameinfo, sockaddr, flags)
-
-    async def sock_sendfile(self, sock, file, offset=0, count=None, *, fallback=True):
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-        self._check_sendfile_params(sock, file, offset, count)
-        try:
-            return await self._sock_sendfile_native(sock, file, offset, count)
-        except events.SendfileNotAvailableError as exc:
-            if not fallback:
-                raise
-        return await self._sock_sendfile_fallback(sock, file, offset, count)
-
-    async def _sock_sendfile_native(self, sock, file, offset, count):
-        # NB: sendfile syscall is not supported for SSL sockets and
-        # non-mmap files even if sendfile is supported by OS
-        raise events.SendfileNotAvailableError(
-            f"syscall sendfile is not available for socket {sock!r} "
-            "and file {file!r} combination"
-        )
-
-    async def _sock_sendfile_fallback(self, sock, file, offset, count):
-        if offset:
-            file.seek(offset)
-        blocksize = (
-            min(count, constants.SENDFILE_FALLBACK_READBUFFER_SIZE)
-            if count
-            else constants.SENDFILE_FALLBACK_READBUFFER_SIZE
-        )
-        buf = bytearray(blocksize)
-        total_sent = 0
-        try:
-            while True:
-                if count:
-                    blocksize = min(count - total_sent, blocksize)
-                    if blocksize <= 0:
-                        break
-                view = memoryview(buf)[:blocksize]
-                read = await self.run_in_executor(None, file.readinto, view)
-                if not read:
-                    break  # EOF
-                await self.sock_sendall(sock, view[:read])
-                total_sent += read
-            return total_sent
-        finally:
-            if total_sent > 0 and hasattr(file, "seek"):
-                file.seek(offset + total_sent)
-
-    def _check_sendfile_params(self, sock, file, offset, count):
-        if "b" not in getattr(file, "mode", "b"):
-            raise ValueError("file should be opened in binary mode")
-        if not sock.type == socket.SOCK_STREAM:
-            raise ValueError("only SOCK_STREAM type sockets are supported")
-        if count is not None:
-            if not isinstance(count, int):
-                raise TypeError(
-                    "count must be a positive integer (got {!r})".format(count)
-                )
-            if count <= 0:
-                raise ValueError(
-                    "count must be a positive integer (got {!r})".format(count)
-                )
-        if not isinstance(offset, int):
-            raise TypeError(
-                "offset must be a non-negative integer (got {!r})".format(offset)
-            )
-        if offset < 0:
-            raise ValueError(
-                "offset must be a non-negative integer (got {!r})".format(offset)
-            )
-
-    async def create_connection(
-        self,
-        protocol_factory,
-        host=None,
-        port=None,
-        *,
-        ssl=None,
-        family=0,
-        proto=0,
-        flags=0,
-        sock=None,
-        local_addr=None,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        """Connect to a TCP server.
-
-        Create a streaming transport connection to a given Internet host and
-        port: socket family AF_INET or socket.AF_INET6 depending on host (or
-        family if specified), socket type SOCK_STREAM. protocol_factory must be
-        a callable returning a protocol instance.
-
-        This method is a coroutine which will try to establish the connection
-        in the background.  When successful, the coroutine returns a
-        (transport, protocol) pair.
-        """
-        if server_hostname is not None and not ssl:
-            raise ValueError("server_hostname is only meaningful with ssl")
-
-        if server_hostname is None and ssl:
-            # Use host as default for server_hostname.  It is an error
-            # if host is empty or not set, e.g. when an
-            # already-connected socket was passed or when only a port
-            # is given.  To avoid this error, you can pass
-            # server_hostname='' -- this will bypass the hostname
-            # check.  (This also means that if host is a numeric
-            # IP/IPv6 address, we will attempt to verify that exact
-            # address; this will probably fail, but it is possible to
-            # create a certificate for a specific IP address, so we
-            # don't judge it here.)
-            if not host:
-                raise ValueError(
-                    "You must set server_hostname " "when using ssl without a host"
-                )
-            server_hostname = host
-
-        if ssl_handshake_timeout is not None and not ssl:
-            raise ValueError("ssl_handshake_timeout is only meaningful with ssl")
-
-        if host is not None or port is not None:
-            if sock is not None:
-                raise ValueError(
-                    "host/port and sock can not be specified at the same time"
-                )
-
-            infos = await self._ensure_resolved(
-                (host, port),
-                family=family,
-                type=socket.SOCK_STREAM,
-                proto=proto,
-                flags=flags,
-                loop=self,
-            )
-            if not infos:
-                raise OSError("getaddrinfo() returned empty list")
-
-            if local_addr is not None:
-                laddr_infos = await self._ensure_resolved(
-                    local_addr,
-                    family=family,
-                    type=socket.SOCK_STREAM,
-                    proto=proto,
-                    flags=flags,
-                    loop=self,
-                )
-                if not laddr_infos:
-                    raise OSError("getaddrinfo() returned empty list")
-
-            exceptions = []
-            for family, type, proto, cname, address in infos:
-                try:
-                    sock = socket.socket(family=family, type=type, proto=proto)
-                    sock.setblocking(False)
-                    if local_addr is not None:
-                        for _, _, _, _, laddr in laddr_infos:
-                            try:
-                                sock.bind(laddr)
-                                break
-                            except OSError as exc:
-                                msg = (
-                                    f"error while attempting to bind on "
-                                    f"address {laddr!r}: "
-                                    f"{exc.strerror.lower()}"
-                                )
-                                exc = OSError(exc.errno, msg)
-                                exceptions.append(exc)
-                        else:
-                            sock.close()
-                            sock = None
-                            continue
-                    if self._debug:
-                        logger.debug("connect %r to %r", sock, address)
-                    await self.sock_connect(sock, address)
-                except OSError as exc:
-                    if sock is not None:
-                        sock.close()
-                    exceptions.append(exc)
-                except:
-                    if sock is not None:
-                        sock.close()
-                    raise
-                else:
-                    break
-            else:
-                if len(exceptions) == 1:
-                    raise exceptions[0]
-                else:
-                    # If they all have the same str(), raise one.
-                    model = str(exceptions[0])
-                    if all(str(exc) == model for exc in exceptions):
-                        raise exceptions[0]
-                    # Raise a combined exception so the user can see all
-                    # the various error messages.
-                    raise OSError(
-                        "Multiple exceptions: {}".format(
-                            ", ".join(str(exc) for exc in exceptions)
-                        )
-                    )
-
-        else:
-            if sock is None:
-                raise ValueError(
-                    "host and port was not specified and no sock specified"
-                )
-            if sock.type != socket.SOCK_STREAM:
-                # We allow AF_INET, AF_INET6, AF_UNIX as long as they
-                # are SOCK_STREAM.
-                # We support passing AF_UNIX sockets even though we have
-                # a dedicated API for that: create_unix_connection.
-                # Disallowing AF_UNIX in this method, breaks backwards
-                # compatibility.
-                raise ValueError(f"A Stream Socket was expected, got {sock!r}")
-
-        transport, protocol = await self._create_connection_transport(
-            sock,
-            protocol_factory,
-            ssl,
-            server_hostname,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-        )
-        if self._debug:
-            # Get the socket from the transport because SSL transport closes
-            # the old socket and creates a new SSL socket
-            sock = transport.get_extra_info("socket")
-            logger.debug(
-                "%r connected to %s:%r: (%r, %r)", sock, host, port, transport, protocol
-            )
-        return transport, protocol
-
-    async def _create_connection_transport(
-        self,
-        sock,
-        protocol_factory,
-        ssl,
-        server_hostname,
-        server_side=False,
-        ssl_handshake_timeout=None,
-    ):
-
-        sock.setblocking(False)
-
-        protocol = protocol_factory()
-        waiter = self.create_future()
-        if ssl:
-            sslcontext = None if isinstance(ssl, bool) else ssl
-            transport = self._make_ssl_transport(
-                sock,
-                protocol,
-                sslcontext,
-                waiter,
-                server_side=server_side,
-                server_hostname=server_hostname,
-                ssl_handshake_timeout=ssl_handshake_timeout,
-            )
-        else:
-            transport = self._make_socket_transport(sock, protocol, waiter)
-
-        try:
-            await waiter
-        except:
-            transport.close()
-            raise
-
-        return transport, protocol
-
-    async def sendfile(self, transport, file, offset=0, count=None, *, fallback=True):
-        """Send a file to transport.
-
-        Return the total number of bytes which were sent.
-
-        The method uses high-performance os.sendfile if available.
-
-        file must be a regular file object opened in binary mode.
-
-        offset tells from where to start reading the file. If specified,
-        count is the total number of bytes to transmit as opposed to
-        sending the file until EOF is reached. File position is updated on
-        return or also in case of error in which case file.tell()
-        can be used to figure out the number of bytes
-        which were sent.
-
-        fallback set to True makes asyncio to manually read and send
-        the file when the platform does not support the sendfile syscall
-        (e.g. Windows or SSL socket on Unix).
-
-        Raise SendfileNotAvailableError if the system does not support
-        sendfile syscall and fallback is False.
-        """
-        if transport.is_closing():
-            raise RuntimeError("Transport is closing")
-        mode = getattr(
-            transport, "_sendfile_compatible", constants._SendfileMode.UNSUPPORTED
-        )
-        if mode is constants._SendfileMode.UNSUPPORTED:
-            raise RuntimeError(f"sendfile is not supported for transport {transport!r}")
-        if mode is constants._SendfileMode.TRY_NATIVE:
-            try:
-                return await self._sendfile_native(transport, file, offset, count)
-            except events.SendfileNotAvailableError as exc:
-                if not fallback:
-                    raise
-
-        if not fallback:
-            raise RuntimeError(
-                f"fallback is disabled and native sendfile is not "
-                f"supported for transport {transport!r}"
-            )
-
-        return await self._sendfile_fallback(transport, file, offset, count)
-
-    async def _sendfile_native(self, transp, file, offset, count):
-        raise events.SendfileNotAvailableError("sendfile syscall is not supported")
-
-    async def _sendfile_fallback(self, transp, file, offset, count):
-        if offset:
-            file.seek(offset)
-        blocksize = min(count, 16384) if count else 16384
-        buf = bytearray(blocksize)
-        total_sent = 0
-        proto = _SendfileFallbackProtocol(transp)
-        try:
-            while True:
-                if count:
-                    blocksize = min(count - total_sent, blocksize)
-                    if blocksize <= 0:
-                        return total_sent
-                view = memoryview(buf)[:blocksize]
-                read = await self.run_in_executor(None, file.readinto, view)
-                if not read:
-                    return total_sent  # EOF
-                await proto.drain()
-                transp.write(view[:read])
-                total_sent += read
-        finally:
-            if total_sent > 0 and hasattr(file, "seek"):
-                file.seek(offset + total_sent)
-            await proto.restore()
-
-    async def start_tls(
-        self,
-        transport,
-        protocol,
-        sslcontext,
-        *,
-        server_side=False,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        """Upgrade transport to TLS.
-
-        Return a new transport that *protocol* should start using
-        immediately.
-        """
-        if ssl is None:
-            raise RuntimeError("Python ssl module is not available")
-
-        if not isinstance(sslcontext, ssl.SSLContext):
-            raise TypeError(
-                f"sslcontext is expected to be an instance of ssl.SSLContext, "
-                f"got {sslcontext!r}"
-            )
-
-        if not getattr(transport, "_start_tls_compatible", False):
-            raise TypeError(f"transport {transport!r} is not supported by start_tls()")
-
-        waiter = self.create_future()
-        ssl_protocol = sslproto.SSLProtocol(
-            self,
-            protocol,
-            sslcontext,
-            waiter,
-            server_side,
-            server_hostname,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-            call_connection_made=False,
-        )
-
-        # Pause early so that "ssl_protocol.data_received()" doesn't
-        # have a chance to get called before "ssl_protocol.connection_made()".
-        transport.pause_reading()
-
-        transport.set_protocol(ssl_protocol)
-        conmade_cb = self.call_soon(ssl_protocol.connection_made, transport)
-        resume_cb = self.call_soon(transport.resume_reading)
-
-        try:
-            await waiter
-        except Exception:
-            transport.close()
-            conmade_cb.cancel()
-            resume_cb.cancel()
-            raise
-
-        return ssl_protocol._app_transport
-
-    async def create_datagram_endpoint(
-        self,
-        protocol_factory,
-        local_addr=None,
-        remote_addr=None,
-        *,
-        family=0,
-        proto=0,
-        flags=0,
-        reuse_address=_unset,
-        reuse_port=None,
-        allow_broadcast=None,
-        sock=None,
-    ):
-        """Create datagram connection."""
-        if sock is not None:
-            if sock.type != socket.SOCK_DGRAM:
-                raise ValueError(f"A UDP Socket was expected, got {sock!r}")
-            if (
-                local_addr
-                or remote_addr
-                or family
-                or proto
-                or flags
-                or reuse_port
-                or allow_broadcast
-            ):
-                # show the problematic kwargs in exception msg
-                opts = dict(
-                    local_addr=local_addr,
-                    remote_addr=remote_addr,
-                    family=family,
-                    proto=proto,
-                    flags=flags,
-                    reuse_address=reuse_address,
-                    reuse_port=reuse_port,
-                    allow_broadcast=allow_broadcast,
-                )
-                problems = ", ".join(f"{k}={v}" for k, v in opts.items() if v)
-                raise ValueError(
-                    f"socket modifier keyword arguments can not be used "
-                    f"when sock is specified. ({problems})"
-                )
-            sock.setblocking(False)
-            r_addr = None
-        else:
-            if not (local_addr or remote_addr):
-                if family == 0:
-                    raise ValueError("unexpected address family")
-                addr_pairs_info = (((family, proto), (None, None)),)
-            elif hasattr(socket, "AF_UNIX") and family == socket.AF_UNIX:
-                for addr in (local_addr, remote_addr):
-                    if addr is not None and not isinstance(addr, str):
-                        raise TypeError("string is expected")
-                addr_pairs_info = (((family, proto), (local_addr, remote_addr)),)
-            else:
-                # join address by (family, protocol)
-                addr_infos = collections.OrderedDict()
-                for idx, addr in ((0, local_addr), (1, remote_addr)):
-                    if addr is not None:
-                        assert (
-                            isinstance(addr, tuple) and len(addr) == 2
-                        ), "2-tuple is expected"
-
-                        infos = await self._ensure_resolved(
-                            addr,
-                            family=family,
-                            type=socket.SOCK_DGRAM,
-                            proto=proto,
-                            flags=flags,
-                            loop=self,
-                        )
-                        if not infos:
-                            raise OSError("getaddrinfo() returned empty list")
-
-                        for fam, _, pro, _, address in infos:
-                            key = (fam, pro)
-                            if key not in addr_infos:
-                                addr_infos[key] = [None, None]
-                            addr_infos[key][idx] = address
-
-                # each addr has to have info for each (family, proto) pair
-                addr_pairs_info = [
-                    (key, addr_pair)
-                    for key, addr_pair in addr_infos.items()
-                    if not (
-                        (local_addr and addr_pair[0] is None)
-                        or (remote_addr and addr_pair[1] is None)
-                    )
-                ]
-
-                if not addr_pairs_info:
-                    raise ValueError("can not get address information")
-
-            exceptions = []
-
-            # bpo-37228
-            if reuse_address is not _unset:
-                if reuse_address:
-                    raise ValueError(
-                        "Passing `reuse_address=True` is no "
-                        "longer supported, as the usage of "
-                        "SO_REUSEPORT in UDP poses a significant "
-                        "security concern."
-                    )
-                else:
-                    warnings.warn(
-                        "The *reuse_address* parameter has been "
-                        "deprecated as of 3.7.6 and is scheduled "
-                        "for removal in 3.11.",
-                        DeprecationWarning,
-                        stacklevel=2,
-                    )
-
-            for ((family, proto), (local_address, remote_address)) in addr_pairs_info:
-                sock = None
-                r_addr = None
-                try:
-                    sock = socket.socket(
-                        family=family, type=socket.SOCK_DGRAM, proto=proto
-                    )
-                    if reuse_port:
-                        _set_reuseport(sock)
-                    if allow_broadcast:
-                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-                    sock.setblocking(False)
-
-                    if local_addr:
-                        sock.bind(local_address)
-                    if remote_addr:
-                        if not allow_broadcast:
-                            await self.sock_connect(sock, remote_address)
-                        r_addr = remote_address
-                except OSError as exc:
-                    if sock is not None:
-                        sock.close()
-                    exceptions.append(exc)
-                except:
-                    if sock is not None:
-                        sock.close()
-                    raise
-                else:
-                    break
-            else:
-                raise exceptions[0]
-
-        protocol = protocol_factory()
-        waiter = self.create_future()
-        transport = self._make_datagram_transport(sock, protocol, r_addr, waiter)
-        if self._debug:
-            if local_addr:
-                logger.info(
-                    "Datagram endpoint local_addr=%r remote_addr=%r "
-                    "created: (%r, %r)",
-                    local_addr,
-                    remote_addr,
-                    transport,
-                    protocol,
-                )
-            else:
-                logger.debug(
-                    "Datagram endpoint remote_addr=%r created: " "(%r, %r)",
-                    remote_addr,
-                    transport,
-                    protocol,
-                )
-
-        try:
-            await waiter
-        except:
-            transport.close()
-            raise
-
-        return transport, protocol
-
-    async def _ensure_resolved(
-        self, address, *, family=0, type=socket.SOCK_STREAM, proto=0, flags=0, loop
-    ):
-        host, port = address[:2]
-        info = _ipaddr_info(host, port, family, type, proto, *address[2:])
-        if info is not None:
-            # "host" is already a resolved IP.
-            return [info]
-        else:
-            return await loop.getaddrinfo(
-                host, port, family=family, type=type, proto=proto, flags=flags
-            )
-
-    async def _create_server_getaddrinfo(self, host, port, family, flags):
-        infos = await self._ensure_resolved(
-            (host, port), family=family, type=socket.SOCK_STREAM, flags=flags, loop=self
-        )
-        if not infos:
-            raise OSError(f"getaddrinfo({host!r}) returned empty list")
-        return infos
-
-    async def create_server(
-        self,
-        protocol_factory,
-        host=None,
-        port=None,
-        *,
-        family=socket.AF_UNSPEC,
-        flags=socket.AI_PASSIVE,
-        sock=None,
-        backlog=100,
-        ssl=None,
-        reuse_address=None,
-        reuse_port=None,
-        ssl_handshake_timeout=None,
-        start_serving=True,
-    ):
-        """Create a TCP server.
-
-        The host parameter can be a string, in that case the TCP server is
-        bound to host and port.
-
-        The host parameter can also be a sequence of strings and in that case
-        the TCP server is bound to all hosts of the sequence. If a host
-        appears multiple times (possibly indirectly e.g. when hostnames
-        resolve to the same IP address), the server is only bound once to that
-        host.
-
-        Return a Server object which can be used to stop the service.
-
-        This method is a coroutine.
-        """
-        if isinstance(ssl, bool):
-            raise TypeError("ssl argument must be an SSLContext or None")
-
-        if ssl_handshake_timeout is not None and ssl is None:
-            raise ValueError("ssl_handshake_timeout is only meaningful with ssl")
-
-        if host is not None or port is not None:
-            if sock is not None:
-                raise ValueError(
-                    "host/port and sock can not be specified at the same time"
-                )
-
-            if reuse_address is None:
-                reuse_address = os.name == "posix" and sys.platform != "cygwin"
-            sockets = []
-            if host == "":
-                hosts = [None]
-            elif isinstance(host, str) or not isinstance(
-                host, collections.abc.Iterable
-            ):
-                hosts = [host]
-            else:
-                hosts = host
-
-            fs = [
-                self._create_server_getaddrinfo(host, port, family=family, flags=flags)
-                for host in hosts
-            ]
-            infos = await tasks.gather(*fs, loop=self)
-            infos = set(itertools.chain.from_iterable(infos))
-
-            completed = False
-            try:
-                for res in infos:
-                    af, socktype, proto, canonname, sa = res
-                    try:
-                        sock = socket.socket(af, socktype, proto)
-                    except socket.error:
-                        # Assume it's a bad family/type/protocol combination.
-                        if self._debug:
-                            logger.warning(
-                                "create_server() failed to create "
-                                "socket.socket(%r, %r, %r)",
-                                af,
-                                socktype,
-                                proto,
-                                exc_info=True,
-                            )
-                        continue
-                    sockets.append(sock)
-                    if reuse_address:
-                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
-                    if reuse_port:
-                        _set_reuseport(sock)
-                    # Disable IPv4/IPv6 dual stack support (enabled by
-                    # default on Linux) which makes a single socket
-                    # listen on both address families.
-                    if (
-                        _HAS_IPv6
-                        and af == socket.AF_INET6
-                        and hasattr(socket, "IPPROTO_IPV6")
-                    ):
-                        sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, True)
-                    try:
-                        sock.bind(sa)
-                    except OSError as err:
-                        raise OSError(
-                            err.errno,
-                            "error while attempting "
-                            "to bind on address %r: %s" % (sa, err.strerror.lower()),
-                        ) from None
-                completed = True
-            finally:
-                if not completed:
-                    for sock in sockets:
-                        sock.close()
-        else:
-            if sock is None:
-                raise ValueError("Neither host/port nor sock were specified")
-            if sock.type != socket.SOCK_STREAM:
-                raise ValueError(f"A Stream Socket was expected, got {sock!r}")
-            sockets = [sock]
-
-        for sock in sockets:
-            sock.setblocking(False)
-
-        server = Server(
-            self, sockets, protocol_factory, ssl, backlog, ssl_handshake_timeout
-        )
-        if start_serving:
-            server._start_serving()
-            # Skip one loop iteration so that all 'loop.add_reader'
-            # go through.
-            await tasks.sleep(0, loop=self)
-
-        if self._debug:
-            logger.info("%r is serving", server)
-        return server
-
-    async def connect_accepted_socket(
-        self, protocol_factory, sock, *, ssl=None, ssl_handshake_timeout=None
-    ):
-        """Handle an accepted connection.
-
-        This is used by servers that accept connections outside of
-        asyncio but that use asyncio to handle connections.
-
-        This method is a coroutine.  When completed, the coroutine
-        returns a (transport, protocol) pair.
-        """
-        if sock.type != socket.SOCK_STREAM:
-            raise ValueError(f"A Stream Socket was expected, got {sock!r}")
-
-        if ssl_handshake_timeout is not None and not ssl:
-            raise ValueError("ssl_handshake_timeout is only meaningful with ssl")
-
-        transport, protocol = await self._create_connection_transport(
-            sock,
-            protocol_factory,
-            ssl,
-            "",
-            server_side=True,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-        )
-        if self._debug:
-            # Get the socket from the transport because SSL transport closes
-            # the old socket and creates a new SSL socket
-            sock = transport.get_extra_info("socket")
-            logger.debug("%r handled: (%r, %r)", sock, transport, protocol)
-        return transport, protocol
-
-    async def connect_read_pipe(self, protocol_factory, pipe):
-        protocol = protocol_factory()
-        waiter = self.create_future()
-        transport = self._make_read_pipe_transport(pipe, protocol, waiter)
-
-        try:
-            await waiter
-        except:
-            transport.close()
-            raise
-
-        if self._debug:
-            logger.debug(
-                "Read pipe %r connected: (%r, %r)", pipe.fileno(), transport, protocol
-            )
-        return transport, protocol
-
-    async def connect_write_pipe(self, protocol_factory, pipe):
-        protocol = protocol_factory()
-        waiter = self.create_future()
-        transport = self._make_write_pipe_transport(pipe, protocol, waiter)
-
-        try:
-            await waiter
-        except:
-            transport.close()
-            raise
-
-        if self._debug:
-            logger.debug(
-                "Write pipe %r connected: (%r, %r)", pipe.fileno(), transport, protocol
-            )
-        return transport, protocol
-
-    def _log_subprocess(self, msg, stdin, stdout, stderr):
-        info = [msg]
-        if stdin is not None:
-            info.append(f"stdin={_format_pipe(stdin)}")
-        if stdout is not None and stderr == subprocess.STDOUT:
-            info.append(f"stdout=stderr={_format_pipe(stdout)}")
-        else:
-            if stdout is not None:
-                info.append(f"stdout={_format_pipe(stdout)}")
-            if stderr is not None:
-                info.append(f"stderr={_format_pipe(stderr)}")
-        logger.debug(" ".join(info))
-
-    async def subprocess_shell(
-        self,
-        protocol_factory,
-        cmd,
-        *,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        universal_newlines=False,
-        shell=True,
-        bufsize=0,
-        **kwargs,
-    ):
-        if not isinstance(cmd, (bytes, str)):
-            raise ValueError("cmd must be a string")
-        if universal_newlines:
-            raise ValueError("universal_newlines must be False")
-        if not shell:
-            raise ValueError("shell must be True")
-        if bufsize != 0:
-            raise ValueError("bufsize must be 0")
-        protocol = protocol_factory()
-        debug_log = None
-        if self._debug:
-            # don't log parameters: they may contain sensitive information
-            # (password) and may be too long
-            debug_log = "run shell command %r" % cmd
-            self._log_subprocess(debug_log, stdin, stdout, stderr)
-        transport = await self._make_subprocess_transport(
-            protocol, cmd, True, stdin, stdout, stderr, bufsize, **kwargs
-        )
-        if self._debug and debug_log is not None:
-            logger.info("%s: %r", debug_log, transport)
-        return transport, protocol
-
-    async def subprocess_exec(
-        self,
-        protocol_factory,
-        program,
-        *args,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        universal_newlines=False,
-        shell=False,
-        bufsize=0,
-        **kwargs,
-    ):
-        if universal_newlines:
-            raise ValueError("universal_newlines must be False")
-        if shell:
-            raise ValueError("shell must be False")
-        if bufsize != 0:
-            raise ValueError("bufsize must be 0")
-        popen_args = (program,) + args
-        for arg in popen_args:
-            if not isinstance(arg, (str, bytes)):
-                raise TypeError(
-                    f"program arguments must be a bytes or text string, "
-                    f"not {type(arg).__name__}"
-                )
-        protocol = protocol_factory()
-        debug_log = None
-        if self._debug:
-            # don't log parameters: they may contain sensitive information
-            # (password) and may be too long
-            debug_log = f"execute program {program!r}"
-            self._log_subprocess(debug_log, stdin, stdout, stderr)
-        transport = await self._make_subprocess_transport(
-            protocol, popen_args, False, stdin, stdout, stderr, bufsize, **kwargs
-        )
-        if self._debug and debug_log is not None:
-            logger.info("%s: %r", debug_log, transport)
-        return transport, protocol
-
-    def get_exception_handler(self):
-        """Return an exception handler, or None if the default one is in use."""
-        return self._exception_handler
-
-    def set_exception_handler(self, handler):
-        """Set handler as the new event loop exception handler.
-
-        If handler is None, the default exception handler will
-        be set.
-
-        If handler is a callable object, it should have a
-        signature matching '(loop, context)', where 'loop'
-        will be a reference to the active event loop, 'context'
-        will be a dict object (see `call_exception_handler()`
-        documentation for details about context).
-        """
-        if handler is not None and not callable(handler):
-            raise TypeError(
-                f"A callable object or None is expected, " f"got {handler!r}"
-            )
-        self._exception_handler = handler
-
-    def default_exception_handler(self, context):
-        """Default exception handler.
-
-        This is called when an exception occurs and no exception
-        handler is set, and can be called by a custom exception
-        handler that wants to defer to the default behavior.
-
-        This default handler logs the error message and other
-        context-dependent information.  In debug mode, a truncated
-        stack trace is also appended showing where the given object
-        (e.g. a handle or future or task) was created, if any.
-
-        The context parameter has the same meaning as in
-        `call_exception_handler()`.
-        """
-        message = context.get("message")
-        if not message:
-            message = "Unhandled exception in event loop"
-
-        exception = context.get("exception")
-        if exception is not None:
-            exc_info = (type(exception), exception, exception.__traceback__)
-        else:
-            exc_info = False
-
-        if (
-            "source_traceback" not in context
-            and self._current_handle is not None
-            and self._current_handle._source_traceback
-        ):
-            context["handle_traceback"] = self._current_handle._source_traceback
-
-        log_lines = [message]
-        for key in sorted(context):
-            if key in {"message", "exception"}:
-                continue
-            value = context[key]
-            if key == "source_traceback":
-                tb = "".join(traceback.format_list(value))
-                value = "Object created at (most recent call last):\n"
-                value += tb.rstrip()
-            elif key == "handle_traceback":
-                tb = "".join(traceback.format_list(value))
-                value = "Handle created at (most recent call last):\n"
-                value += tb.rstrip()
-            else:
-                value = repr(value)
-            log_lines.append(f"{key}: {value}")
-
-        logger.error("\n".join(log_lines), exc_info=exc_info)
-
-    def call_exception_handler(self, context):
-        """Call the current event loop's exception handler.
-
-        The context argument is a dict containing the following keys:
-
-        - 'message': Error message;
-        - 'exception' (optional): Exception object;
-        - 'future' (optional): Future instance;
-        - 'task' (optional): Task instance;
-        - 'handle' (optional): Handle instance;
-        - 'protocol' (optional): Protocol instance;
-        - 'transport' (optional): Transport instance;
-        - 'socket' (optional): Socket instance;
-        - 'asyncgen' (optional): Asynchronous generator that caused
-                                 the exception.
-
-        New keys maybe introduced in the future.
-
-        Note: do not overload this method in an event loop subclass.
-        For custom exception handling, use the
-        `set_exception_handler()` method.
-        """
-        if self._exception_handler is None:
-            try:
-                self.default_exception_handler(context)
-            except Exception:
-                # Second protection layer for unexpected errors
-                # in the default implementation, as well as for subclassed
-                # event loops with overloaded "default_exception_handler".
-                logger.error("Exception in default exception handler", exc_info=True)
-        else:
-            try:
-                self._exception_handler(self, context)
-            except Exception as exc:
-                # Exception in the user set custom exception handler.
-                try:
-                    # Let's try default handler.
-                    self.default_exception_handler(
-                        {
-                            "message": "Unhandled error in exception handler",
-                            "exception": exc,
-                            "context": context,
-                        }
-                    )
-                except Exception:
-                    # Guard 'default_exception_handler' in case it is
-                    # overloaded.
-                    logger.error(
-                        "Exception in default exception handler "
-                        "while handling an unexpected error "
-                        "in custom exception handler",
-                        exc_info=True,
-                    )
-
-    def _add_callback(self, handle):
-        """Add a Handle to _scheduled (TimerHandle) or _ready."""
-        assert isinstance(handle, events.Handle), "A Handle is required here"
-        if handle._cancelled:
-            return
-        assert not isinstance(handle, events.TimerHandle)
-        self._ready.append(handle)
-
-    def _add_callback_signalsafe(self, handle):
-        """Like _add_callback() but called from a signal handler."""
-        self._add_callback(handle)
-        self._write_to_self()
-
-    def _timer_handle_cancelled(self, handle):
-        """Notification that a TimerHandle has been cancelled."""
-        if handle._scheduled:
-            self._timer_cancelled_count += 1
-
-    def _run_once(self):
-        """Run one full iteration of the event loop.
-
-        This calls all currently ready callbacks, polls for I/O,
-        schedules the resulting callbacks, and finally schedules
-        'call_later' callbacks.
-        """
-
-        sched_count = len(self._scheduled)
-        if (
-            sched_count > _MIN_SCHEDULED_TIMER_HANDLES
-            and self._timer_cancelled_count / sched_count
-            > _MIN_CANCELLED_TIMER_HANDLES_FRACTION
-        ):
-            # Remove delayed calls that were cancelled if their number
-            # is too high
-            new_scheduled = []
-            for handle in self._scheduled:
-                if handle._cancelled:
-                    handle._scheduled = False
-                else:
-                    new_scheduled.append(handle)
-
-            heapq.heapify(new_scheduled)
-            self._scheduled = new_scheduled
-            self._timer_cancelled_count = 0
-        else:
-            # Remove delayed calls that were cancelled from head of queue.
-            while self._scheduled and self._scheduled[0]._cancelled:
-                self._timer_cancelled_count -= 1
-                handle = heapq.heappop(self._scheduled)
-                handle._scheduled = False
-
-        timeout = None
-        if self._ready or self._stopping:
-            timeout = 0
-        elif self._scheduled:
-            # Compute the desired timeout.
-            when = self._scheduled[0]._when
-            timeout = min(max(0, when - self.time()), MAXIMUM_SELECT_TIMEOUT)
-
-        if self._debug and timeout != 0:
-            t0 = self.time()
-            event_list = self._selector.select(timeout)
-            dt = self.time() - t0
-            if dt >= 1.0:
-                level = logging.INFO
-            else:
-                level = logging.DEBUG
-            nevent = len(event_list)
-            if timeout is None:
-                logger.log(level, "poll took %.3f ms: %s events", dt * 1e3, nevent)
-            elif nevent:
-                logger.log(
-                    level,
-                    "poll %.3f ms took %.3f ms: %s events",
-                    timeout * 1e3,
-                    dt * 1e3,
-                    nevent,
-                )
-            elif dt >= 1.0:
-                logger.log(
-                    level, "poll %.3f ms took %.3f ms: timeout", timeout * 1e3, dt * 1e3
-                )
-        else:
-            event_list = self._selector.select(timeout)
-        self._process_events(event_list)
-
-        # Handle 'later' callbacks that are ready.
-        end_time = self.time() + self._clock_resolution
-        while self._scheduled:
-            handle = self._scheduled[0]
-            if handle._when >= end_time:
-                break
-            handle = heapq.heappop(self._scheduled)
-            handle._scheduled = False
-            self._ready.append(handle)
-
-        # This is the only place where callbacks are actually *called*.
-        # All other places just add them to ready.
-        # Note: We run all currently scheduled callbacks, but not any
-        # callbacks scheduled by callbacks run this time around --
-        # they will be run the next time (after another I/O poll).
-        # Use an idiom that is thread-safe without using locks.
-        ntodo = len(self._ready)
-        for i in range(ntodo):
-            handle = self._ready.popleft()
-            if handle._cancelled:
-                continue
-            if self._debug:
-                try:
-                    self._current_handle = handle
-                    t0 = self.time()
-                    handle._run()
-                    dt = self.time() - t0
-                    if dt >= self.slow_callback_duration:
-                        logger.warning(
-                            "Executing %s took %.3f seconds", _format_handle(handle), dt
-                        )
-                finally:
-                    self._current_handle = None
-            else:
-                handle._run()
-        handle = None  # Needed to break cycles when an exception occurs.
-
-    def _set_coroutine_origin_tracking(self, enabled):
-        if bool(enabled) == bool(self._coroutine_origin_tracking_enabled):
-            return
-
-        if enabled:
-            self._coroutine_origin_tracking_saved_depth = (
-                sys.get_coroutine_origin_tracking_depth()
-            )
-            sys.set_coroutine_origin_tracking_depth(constants.DEBUG_STACK_DEPTH)
-        else:
-            sys.set_coroutine_origin_tracking_depth(
-                self._coroutine_origin_tracking_saved_depth
-            )
-
-        self._coroutine_origin_tracking_enabled = enabled
-
-    def get_debug(self):
-        return self._debug
-
-    def set_debug(self, enabled):
-        self._debug = enabled
-
-        if self.is_running():
-            self.call_soon_threadsafe(self._set_coroutine_origin_tracking, enabled)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/base_futures.py b/addon/globalPlugins/spellcheck/libs/asyncio/base_futures.py
deleted file mode 100644
index 16f8cb2..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/base_futures.py
+++ /dev/null
@@ -1,73 +0,0 @@
-__all__ = ()
-
-import concurrent.futures._base
-import reprlib
-
-from . import format_helpers
-
-Error = concurrent.futures._base.Error
-CancelledError = concurrent.futures.CancelledError
-TimeoutError = concurrent.futures.TimeoutError
-
-
-class InvalidStateError(Error):
-    """The operation is not allowed in this state."""
-
-
-# States for Future.
-_PENDING = "PENDING"
-_CANCELLED = "CANCELLED"
-_FINISHED = "FINISHED"
-
-
-def isfuture(obj):
-    """Check for a Future.
-
-    This returns True when obj is a Future instance or is advertising
-    itself as duck-type compatible by setting _asyncio_future_blocking.
-    See comment in Future for more details.
-    """
-    return (
-        hasattr(obj.__class__, "_asyncio_future_blocking")
-        and obj._asyncio_future_blocking is not None
-    )
-
-
-def _format_callbacks(cb):
-    """helper function for Future.__repr__"""
-    size = len(cb)
-    if not size:
-        cb = ""
-
-    def format_cb(callback):
-        return format_helpers._format_callback_source(callback, ())
-
-    if size == 1:
-        cb = format_cb(cb[0][0])
-    elif size == 2:
-        cb = "{}, {}".format(format_cb(cb[0][0]), format_cb(cb[1][0]))
-    elif size > 2:
-        cb = "{}, <{} more>, {}".format(
-            format_cb(cb[0][0]), size - 2, format_cb(cb[-1][0])
-        )
-    return f"cb=[{cb}]"
-
-
-def _future_repr_info(future):
-    # (Future) -> str
-    """helper function for Future.__repr__"""
-    info = [future._state.lower()]
-    if future._state == _FINISHED:
-        if future._exception is not None:
-            info.append(f"exception={future._exception!r}")
-        else:
-            # use reprlib to limit the length of the output, especially
-            # for very long strings
-            result = reprlib.repr(future._result)
-            info.append(f"result={result}")
-    if future._callbacks:
-        info.append(_format_callbacks(future._callbacks))
-    if future._source_traceback:
-        frame = future._source_traceback[-1]
-        info.append(f"created at {frame[0]}:{frame[1]}")
-    return info
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/base_subprocess.py b/addon/globalPlugins/spellcheck/libs/asyncio/base_subprocess.py
deleted file mode 100644
index 7f55664..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/base_subprocess.py
+++ /dev/null
@@ -1,299 +0,0 @@
-import collections
-import subprocess
-import warnings
-
-from . import protocols
-from . import transports
-from .log import logger
-
-
-class BaseSubprocessTransport(transports.SubprocessTransport):
-    def __init__(
-        self,
-        loop,
-        protocol,
-        args,
-        shell,
-        stdin,
-        stdout,
-        stderr,
-        bufsize,
-        waiter=None,
-        extra=None,
-        **kwargs,
-    ):
-        super().__init__(extra)
-        self._closed = False
-        self._protocol = protocol
-        self._loop = loop
-        self._proc = None
-        self._pid = None
-        self._returncode = None
-        self._exit_waiters = []
-        self._pending_calls = collections.deque()
-        self._pipes = {}
-        self._finished = False
-
-        if stdin == subprocess.PIPE:
-            self._pipes[0] = None
-        if stdout == subprocess.PIPE:
-            self._pipes[1] = None
-        if stderr == subprocess.PIPE:
-            self._pipes[2] = None
-
-        # Create the child process: set the _proc attribute
-        try:
-            self._start(
-                args=args,
-                shell=shell,
-                stdin=stdin,
-                stdout=stdout,
-                stderr=stderr,
-                bufsize=bufsize,
-                **kwargs,
-            )
-        except:
-            self.close()
-            raise
-
-        self._pid = self._proc.pid
-        self._extra["subprocess"] = self._proc
-
-        if self._loop.get_debug():
-            if isinstance(args, (bytes, str)):
-                program = args
-            else:
-                program = args[0]
-            logger.debug("process %r created: pid %s", program, self._pid)
-
-        self._loop.create_task(self._connect_pipes(waiter))
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self._closed:
-            info.append("closed")
-        if self._pid is not None:
-            info.append(f"pid={self._pid}")
-        if self._returncode is not None:
-            info.append(f"returncode={self._returncode}")
-        elif self._pid is not None:
-            info.append("running")
-        else:
-            info.append("not started")
-
-        stdin = self._pipes.get(0)
-        if stdin is not None:
-            info.append(f"stdin={stdin.pipe}")
-
-        stdout = self._pipes.get(1)
-        stderr = self._pipes.get(2)
-        if stdout is not None and stderr is stdout:
-            info.append(f"stdout=stderr={stdout.pipe}")
-        else:
-            if stdout is not None:
-                info.append(f"stdout={stdout.pipe}")
-            if stderr is not None:
-                info.append(f"stderr={stderr.pipe}")
-
-        return "<{}>".format(" ".join(info))
-
-    def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
-        raise NotImplementedError
-
-    def set_protocol(self, protocol):
-        self._protocol = protocol
-
-    def get_protocol(self):
-        return self._protocol
-
-    def is_closing(self):
-        return self._closed
-
-    def close(self):
-        if self._closed:
-            return
-        self._closed = True
-
-        for proto in self._pipes.values():
-            if proto is None:
-                continue
-            proto.pipe.close()
-
-        if (
-            self._proc is not None
-            and
-            # has the child process finished?
-            self._returncode is None
-            and
-            # the child process has finished, but the
-            # transport hasn't been notified yet?
-            self._proc.poll() is None
-        ):
-
-            if self._loop.get_debug():
-                logger.warning("Close running child process: kill %r", self)
-
-            try:
-                self._proc.kill()
-            except ProcessLookupError:
-                pass
-
-            # Don't clear the _proc reference yet: _post_init() may still run
-
-    def __del__(self):
-        if not self._closed:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self.close()
-
-    def get_pid(self):
-        return self._pid
-
-    def get_returncode(self):
-        return self._returncode
-
-    def get_pipe_transport(self, fd):
-        if fd in self._pipes:
-            return self._pipes[fd].pipe
-        else:
-            return None
-
-    def _check_proc(self):
-        if self._proc is None:
-            raise ProcessLookupError()
-
-    def send_signal(self, signal):
-        self._check_proc()
-        self._proc.send_signal(signal)
-
-    def terminate(self):
-        self._check_proc()
-        self._proc.terminate()
-
-    def kill(self):
-        self._check_proc()
-        self._proc.kill()
-
-    async def _connect_pipes(self, waiter):
-        try:
-            proc = self._proc
-            loop = self._loop
-
-            if proc.stdin is not None:
-                _, pipe = await loop.connect_write_pipe(
-                    lambda: WriteSubprocessPipeProto(self, 0), proc.stdin
-                )
-                self._pipes[0] = pipe
-
-            if proc.stdout is not None:
-                _, pipe = await loop.connect_read_pipe(
-                    lambda: ReadSubprocessPipeProto(self, 1), proc.stdout
-                )
-                self._pipes[1] = pipe
-
-            if proc.stderr is not None:
-                _, pipe = await loop.connect_read_pipe(
-                    lambda: ReadSubprocessPipeProto(self, 2), proc.stderr
-                )
-                self._pipes[2] = pipe
-
-            assert self._pending_calls is not None
-
-            loop.call_soon(self._protocol.connection_made, self)
-            for callback, data in self._pending_calls:
-                loop.call_soon(callback, *data)
-            self._pending_calls = None
-        except Exception as exc:
-            if waiter is not None and not waiter.cancelled():
-                waiter.set_exception(exc)
-        else:
-            if waiter is not None and not waiter.cancelled():
-                waiter.set_result(None)
-
-    def _call(self, cb, *data):
-        if self._pending_calls is not None:
-            self._pending_calls.append((cb, data))
-        else:
-            self._loop.call_soon(cb, *data)
-
-    def _pipe_connection_lost(self, fd, exc):
-        self._call(self._protocol.pipe_connection_lost, fd, exc)
-        self._try_finish()
-
-    def _pipe_data_received(self, fd, data):
-        self._call(self._protocol.pipe_data_received, fd, data)
-
-    def _process_exited(self, returncode):
-        assert returncode is not None, returncode
-        assert self._returncode is None, self._returncode
-        if self._loop.get_debug():
-            logger.info("%r exited with return code %r", self, returncode)
-        self._returncode = returncode
-        if self._proc.returncode is None:
-            # asyncio uses a child watcher: copy the status into the Popen
-            # object. On Python 3.6, it is required to avoid a ResourceWarning.
-            self._proc.returncode = returncode
-        self._call(self._protocol.process_exited)
-        self._try_finish()
-
-        # wake up futures waiting for wait()
-        for waiter in self._exit_waiters:
-            if not waiter.cancelled():
-                waiter.set_result(returncode)
-        self._exit_waiters = None
-
-    async def _wait(self):
-        """Wait until the process exit and return the process return code.
-
-        This method is a coroutine."""
-        if self._returncode is not None:
-            return self._returncode
-
-        waiter = self._loop.create_future()
-        self._exit_waiters.append(waiter)
-        return await waiter
-
-    def _try_finish(self):
-        assert not self._finished
-        if self._returncode is None:
-            return
-        if all(p is not None and p.disconnected for p in self._pipes.values()):
-            self._finished = True
-            self._call(self._call_connection_lost, None)
-
-    def _call_connection_lost(self, exc):
-        try:
-            self._protocol.connection_lost(exc)
-        finally:
-            self._loop = None
-            self._proc = None
-            self._protocol = None
-
-
-class WriteSubprocessPipeProto(protocols.BaseProtocol):
-    def __init__(self, proc, fd):
-        self.proc = proc
-        self.fd = fd
-        self.pipe = None
-        self.disconnected = False
-
-    def connection_made(self, transport):
-        self.pipe = transport
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__} fd={self.fd} pipe={self.pipe!r}>"
-
-    def connection_lost(self, exc):
-        self.disconnected = True
-        self.proc._pipe_connection_lost(self.fd, exc)
-        self.proc = None
-
-    def pause_writing(self):
-        self.proc._protocol.pause_writing()
-
-    def resume_writing(self):
-        self.proc._protocol.resume_writing()
-
-
-class ReadSubprocessPipeProto(WriteSubprocessPipeProto, protocols.Protocol):
-    def data_received(self, data):
-        self.proc._pipe_data_received(self.fd, data)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/base_tasks.py b/addon/globalPlugins/spellcheck/libs/asyncio/base_tasks.py
deleted file mode 100644
index 0cad59e..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/base_tasks.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import linecache
-import traceback
-
-from . import base_futures
-from . import coroutines
-
-
-def _task_repr_info(task):
-    info = base_futures._future_repr_info(task)
-
-    if task._must_cancel:
-        # replace status
-        info[0] = "cancelling"
-
-    coro = coroutines._format_coroutine(task._coro)
-    info.insert(1, f"coro=<{coro}>")
-
-    if task._fut_waiter is not None:
-        info.insert(2, f"wait_for={task._fut_waiter!r}")
-    return info
-
-
-def _task_get_stack(task, limit):
-    frames = []
-    try:
-        # 'async def' coroutines
-        f = task._coro.cr_frame
-    except AttributeError:
-        f = task._coro.gi_frame
-    if f is not None:
-        while f is not None:
-            if limit is not None:
-                if limit <= 0:
-                    break
-                limit -= 1
-            frames.append(f)
-            f = f.f_back
-        frames.reverse()
-    elif task._exception is not None:
-        tb = task._exception.__traceback__
-        while tb is not None:
-            if limit is not None:
-                if limit <= 0:
-                    break
-                limit -= 1
-            frames.append(tb.tb_frame)
-            tb = tb.tb_next
-    return frames
-
-
-def _task_print_stack(task, limit, file):
-    extracted_list = []
-    checked = set()
-    for f in task.get_stack(limit=limit):
-        lineno = f.f_lineno
-        co = f.f_code
-        filename = co.co_filename
-        name = co.co_name
-        if filename not in checked:
-            checked.add(filename)
-            linecache.checkcache(filename)
-        line = linecache.getline(filename, lineno, f.f_globals)
-        extracted_list.append((filename, lineno, name, line))
-
-    exc = task._exception
-    if not extracted_list:
-        print(f"No stack for {task!r}", file=file)
-    elif exc is not None:
-        print(f"Traceback for {task!r} (most recent call last):", file=file)
-    else:
-        print(f"Stack for {task!r} (most recent call last):", file=file)
-
-    traceback.print_list(extracted_list, file=file)
-    if exc is not None:
-        for line in traceback.format_exception_only(exc.__class__, exc):
-            print(line, file=file, end="")
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/constants.py b/addon/globalPlugins/spellcheck/libs/asyncio/constants.py
deleted file mode 100644
index 33feed6..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/constants.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import enum
-
-# After the connection is lost, log warnings after this many write()s.
-LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5
-
-# Seconds to wait before retrying accept().
-ACCEPT_RETRY_DELAY = 1
-
-# Number of stack entries to capture in debug mode.
-# The larger the number, the slower the operation in debug mode
-# (see extract_stack() in format_helpers.py).
-DEBUG_STACK_DEPTH = 10
-
-# Number of seconds to wait for SSL handshake to complete
-# The default timeout matches that of Nginx.
-SSL_HANDSHAKE_TIMEOUT = 60.0
-
-# Used in sendfile fallback code.  We use fallback for platforms
-# that don't support sendfile, or for TLS connections.
-SENDFILE_FALLBACK_READBUFFER_SIZE = 1024 * 256
-
-# The enum should be here to break circular dependencies between
-# base_events and sslproto
-class _SendfileMode(enum.Enum):
-    UNSUPPORTED = enum.auto()
-    TRY_NATIVE = enum.auto()
-    FALLBACK = enum.auto()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/coroutines.py b/addon/globalPlugins/spellcheck/libs/asyncio/coroutines.py
deleted file mode 100644
index 99b9439..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/coroutines.py
+++ /dev/null
@@ -1,281 +0,0 @@
-__all__ = "coroutine", "iscoroutinefunction", "iscoroutine"
-
-import collections.abc
-import functools
-import inspect
-import os
-import sys
-import traceback
-import types
-
-from . import base_futures
-from . import constants
-from . import format_helpers
-from .log import logger
-
-
-def _is_debug_mode():
-    # If you set _DEBUG to true, @coroutine will wrap the resulting
-    # generator objects in a CoroWrapper instance (defined below).  That
-    # instance will log a message when the generator is never iterated
-    # over, which may happen when you forget to use "await" or "yield from"
-    # with a coroutine call.
-    # Note that the value of the _DEBUG flag is taken
-    # when the decorator is used, so to be of any use it must be set
-    # before you define your coroutines.  A downside of using this feature
-    # is that tracebacks show entries for the CoroWrapper.__next__ method
-    # when _DEBUG is true.
-    return sys.flags.dev_mode or (
-        not sys.flags.ignore_environment and bool(os.environ.get("PYTHONASYNCIODEBUG"))
-    )
-
-
-_DEBUG = _is_debug_mode()
-
-
-class CoroWrapper:
-    # Wrapper for coroutine object in _DEBUG mode.
-
-    def __init__(self, gen, func=None):
-        assert inspect.isgenerator(gen) or inspect.iscoroutine(gen), gen
-        self.gen = gen
-        self.func = func  # Used to unwrap @coroutine decorator
-        self._source_traceback = format_helpers.extract_stack(sys._getframe(1))
-        self.__name__ = getattr(gen, "__name__", None)
-        self.__qualname__ = getattr(gen, "__qualname__", None)
-
-    def __repr__(self):
-        coro_repr = _format_coroutine(self)
-        if self._source_traceback:
-            frame = self._source_traceback[-1]
-            coro_repr += f", created at {frame[0]}:{frame[1]}"
-
-        return f"<{self.__class__.__name__} {coro_repr}>"
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return self.gen.send(None)
-
-    def send(self, value):
-        return self.gen.send(value)
-
-    def throw(self, type, value=None, traceback=None):
-        return self.gen.throw(type, value, traceback)
-
-    def close(self):
-        return self.gen.close()
-
-    @property
-    def gi_frame(self):
-        return self.gen.gi_frame
-
-    @property
-    def gi_running(self):
-        return self.gen.gi_running
-
-    @property
-    def gi_code(self):
-        return self.gen.gi_code
-
-    def __await__(self):
-        return self
-
-    @property
-    def gi_yieldfrom(self):
-        return self.gen.gi_yieldfrom
-
-    def __del__(self):
-        # Be careful accessing self.gen.frame -- self.gen might not exist.
-        gen = getattr(self, "gen", None)
-        frame = getattr(gen, "gi_frame", None)
-        if frame is not None and frame.f_lasti == -1:
-            msg = f"{self!r} was never yielded from"
-            tb = getattr(self, "_source_traceback", ())
-            if tb:
-                tb = "".join(traceback.format_list(tb))
-                msg += (
-                    f"\nCoroutine object created at "
-                    f"(most recent call last, truncated to "
-                    f"{constants.DEBUG_STACK_DEPTH} last lines):\n"
-                )
-                msg += tb.rstrip()
-            logger.error(msg)
-
-
-def coroutine(func):
-    """Decorator to mark coroutines.
-
-    If the coroutine is not yielded from before it is destroyed,
-    an error message is logged.
-    """
-    if inspect.iscoroutinefunction(func):
-        # In Python 3.5 that's all we need to do for coroutines
-        # defined with "async def".
-        return func
-
-    if inspect.isgeneratorfunction(func):
-        coro = func
-    else:
-
-        @functools.wraps(func)
-        def coro(*args, **kw):
-            res = func(*args, **kw)
-            if (
-                base_futures.isfuture(res)
-                or inspect.isgenerator(res)
-                or isinstance(res, CoroWrapper)
-            ):
-                res = yield from res
-            else:
-                # If 'res' is an awaitable, run it.
-                try:
-                    await_meth = res.__await__
-                except AttributeError:
-                    pass
-                else:
-                    if isinstance(res, collections.abc.Awaitable):
-                        res = yield from await_meth()
-            return res
-
-    coro = types.coroutine(coro)
-    if not _DEBUG:
-        wrapper = coro
-    else:
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwds):
-            w = CoroWrapper(coro(*args, **kwds), func=func)
-            if w._source_traceback:
-                del w._source_traceback[-1]
-            # Python < 3.5 does not implement __qualname__
-            # on generator objects, so we set it manually.
-            # We use getattr as some callables (such as
-            # functools.partial may lack __qualname__).
-            w.__name__ = getattr(func, "__name__", None)
-            w.__qualname__ = getattr(func, "__qualname__", None)
-            return w
-
-    wrapper._is_coroutine = _is_coroutine  # For iscoroutinefunction().
-    return wrapper
-
-
-# A marker for iscoroutinefunction.
-_is_coroutine = object()
-
-
-def iscoroutinefunction(func):
-    """Return True if func is a decorated coroutine function."""
-    return (
-        inspect.iscoroutinefunction(func)
-        or getattr(func, "_is_coroutine", None) is _is_coroutine
-    )
-
-
-# Prioritize native coroutine check to speed-up
-# asyncio.iscoroutine.
-_COROUTINE_TYPES = (
-    types.CoroutineType,
-    types.GeneratorType,
-    collections.abc.Coroutine,
-    CoroWrapper,
-)
-_iscoroutine_typecache = set()
-
-
-def iscoroutine(obj):
-    """Return True if obj is a coroutine object."""
-    if type(obj) in _iscoroutine_typecache:
-        return True
-
-    if isinstance(obj, _COROUTINE_TYPES):
-        # Just in case we don't want to cache more than 100
-        # positive types.  That shouldn't ever happen, unless
-        # someone stressing the system on purpose.
-        if len(_iscoroutine_typecache) < 100:
-            _iscoroutine_typecache.add(type(obj))
-        return True
-    else:
-        return False
-
-
-def _format_coroutine(coro):
-    assert iscoroutine(coro)
-
-    is_corowrapper = isinstance(coro, CoroWrapper)
-
-    def get_name(coro):
-        # Coroutines compiled with Cython sometimes don't have
-        # proper __qualname__ or __name__.  While that is a bug
-        # in Cython, asyncio shouldn't crash with an AttributeError
-        # in its __repr__ functions.
-        if is_corowrapper:
-            return format_helpers._format_callback(coro.func, (), {})
-
-        if hasattr(coro, "__qualname__") and coro.__qualname__:
-            coro_name = coro.__qualname__
-        elif hasattr(coro, "__name__") and coro.__name__:
-            coro_name = coro.__name__
-        else:
-            # Stop masking Cython bugs, expose them in a friendly way.
-            coro_name = f"<{type(coro).__name__} without __name__>"
-        return f"{coro_name}()"
-
-    def is_running(coro):
-        try:
-            return coro.cr_running
-        except AttributeError:
-            try:
-                return coro.gi_running
-            except AttributeError:
-                return False
-
-    coro_code = None
-    if hasattr(coro, "cr_code") and coro.cr_code:
-        coro_code = coro.cr_code
-    elif hasattr(coro, "gi_code") and coro.gi_code:
-        coro_code = coro.gi_code
-
-    coro_name = get_name(coro)
-
-    if not coro_code:
-        # Built-in types might not have __qualname__ or __name__.
-        if is_running(coro):
-            return f"{coro_name} running"
-        else:
-            return coro_name
-
-    coro_frame = None
-    if hasattr(coro, "gi_frame") and coro.gi_frame:
-        coro_frame = coro.gi_frame
-    elif hasattr(coro, "cr_frame") and coro.cr_frame:
-        coro_frame = coro.cr_frame
-
-    # If Cython's coroutine has a fake code object without proper
-    # co_filename -- expose that.
-    filename = coro_code.co_filename or "<empty co_filename>"
-
-    lineno = 0
-    if (
-        is_corowrapper
-        and coro.func is not None
-        and not inspect.isgeneratorfunction(coro.func)
-    ):
-        source = format_helpers._get_function_source(coro.func)
-        if source is not None:
-            filename, lineno = source
-        if coro_frame is None:
-            coro_repr = f"{coro_name} done, defined at {filename}:{lineno}"
-        else:
-            coro_repr = f"{coro_name} running, defined at {filename}:{lineno}"
-
-    elif coro_frame is not None:
-        lineno = coro_frame.f_lineno
-        coro_repr = f"{coro_name} running at {filename}:{lineno}"
-
-    else:
-        lineno = coro_code.co_firstlineno
-        coro_repr = f"{coro_name} done, defined at {filename}:{lineno}"
-
-    return coro_repr
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/events.py b/addon/globalPlugins/spellcheck/libs/asyncio/events.py
deleted file mode 100644
index 8061157..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/events.py
+++ /dev/null
@@ -1,871 +0,0 @@
-"""Event loop and event loop policy."""
-
-__all__ = (
-    "AbstractEventLoopPolicy",
-    "AbstractEventLoop",
-    "AbstractServer",
-    "Handle",
-    "TimerHandle",
-    "SendfileNotAvailableError",
-    "get_event_loop_policy",
-    "set_event_loop_policy",
-    "get_event_loop",
-    "set_event_loop",
-    "new_event_loop",
-    "get_child_watcher",
-    "set_child_watcher",
-    "_set_running_loop",
-    "get_running_loop",
-    "_get_running_loop",
-)
-
-import contextvars
-import os
-import socket
-import subprocess
-import sys
-import threading
-
-from . import format_helpers
-
-
-class SendfileNotAvailableError(RuntimeError):
-    """Sendfile syscall is not available.
-
-    Raised if OS does not support sendfile syscall for given socket or
-    file type.
-    """
-
-
-class Handle:
-    """Object returned by callback registration methods."""
-
-    __slots__ = (
-        "_callback",
-        "_args",
-        "_cancelled",
-        "_loop",
-        "_source_traceback",
-        "_repr",
-        "__weakref__",
-        "_context",
-    )
-
-    def __init__(self, callback, args, loop, context=None):
-        if context is None:
-            context = contextvars.copy_context()
-        self._context = context
-        self._loop = loop
-        self._callback = callback
-        self._args = args
-        self._cancelled = False
-        self._repr = None
-        if self._loop.get_debug():
-            self._source_traceback = format_helpers.extract_stack(sys._getframe(1))
-        else:
-            self._source_traceback = None
-
-    def _repr_info(self):
-        info = [self.__class__.__name__]
-        if self._cancelled:
-            info.append("cancelled")
-        if self._callback is not None:
-            info.append(
-                format_helpers._format_callback_source(self._callback, self._args)
-            )
-        if self._source_traceback:
-            frame = self._source_traceback[-1]
-            info.append(f"created at {frame[0]}:{frame[1]}")
-        return info
-
-    def __repr__(self):
-        if self._repr is not None:
-            return self._repr
-        info = self._repr_info()
-        return "<{}>".format(" ".join(info))
-
-    def cancel(self):
-        if not self._cancelled:
-            self._cancelled = True
-            if self._loop.get_debug():
-                # Keep a representation in debug mode to keep callback and
-                # parameters. For example, to log the warning
-                # "Executing <Handle...> took 2.5 second"
-                self._repr = repr(self)
-            self._callback = None
-            self._args = None
-
-    def cancelled(self):
-        return self._cancelled
-
-    def _run(self):
-        try:
-            self._context.run(self._callback, *self._args)
-        except Exception as exc:
-            cb = format_helpers._format_callback_source(self._callback, self._args)
-            msg = f"Exception in callback {cb}"
-            context = {
-                "message": msg,
-                "exception": exc,
-                "handle": self,
-            }
-            if self._source_traceback:
-                context["source_traceback"] = self._source_traceback
-            self._loop.call_exception_handler(context)
-        self = None  # Needed to break cycles when an exception occurs.
-
-
-class TimerHandle(Handle):
-    """Object returned by timed callback registration methods."""
-
-    __slots__ = ["_scheduled", "_when"]
-
-    def __init__(self, when, callback, args, loop, context=None):
-        assert when is not None
-        super().__init__(callback, args, loop, context)
-        if self._source_traceback:
-            del self._source_traceback[-1]
-        self._when = when
-        self._scheduled = False
-
-    def _repr_info(self):
-        info = super()._repr_info()
-        pos = 2 if self._cancelled else 1
-        info.insert(pos, f"when={self._when}")
-        return info
-
-    def __hash__(self):
-        return hash(self._when)
-
-    def __lt__(self, other):
-        return self._when < other._when
-
-    def __le__(self, other):
-        if self._when < other._when:
-            return True
-        return self.__eq__(other)
-
-    def __gt__(self, other):
-        return self._when > other._when
-
-    def __ge__(self, other):
-        if self._when > other._when:
-            return True
-        return self.__eq__(other)
-
-    def __eq__(self, other):
-        if isinstance(other, TimerHandle):
-            return (
-                self._when == other._when
-                and self._callback == other._callback
-                and self._args == other._args
-                and self._cancelled == other._cancelled
-            )
-        return NotImplemented
-
-    def __ne__(self, other):
-        equal = self.__eq__(other)
-        return NotImplemented if equal is NotImplemented else not equal
-
-    def cancel(self):
-        if not self._cancelled:
-            self._loop._timer_handle_cancelled(self)
-        super().cancel()
-
-    def when(self):
-        """Return a scheduled callback time.
-
-        The time is an absolute timestamp, using the same time
-        reference as loop.time().
-        """
-        return self._when
-
-
-class AbstractServer:
-    """Abstract server returned by create_server()."""
-
-    def close(self):
-        """Stop serving.  This leaves existing connections open."""
-        raise NotImplementedError
-
-    def get_loop(self):
-        """Get the event loop the Server object is attached to."""
-        raise NotImplementedError
-
-    def is_serving(self):
-        """Return True if the server is accepting connections."""
-        raise NotImplementedError
-
-    async def start_serving(self):
-        """Start accepting connections.
-
-        This method is idempotent, so it can be called when
-        the server is already being serving.
-        """
-        raise NotImplementedError
-
-    async def serve_forever(self):
-        """Start accepting connections until the coroutine is cancelled.
-
-        The server is closed when the coroutine is cancelled.
-        """
-        raise NotImplementedError
-
-    async def wait_closed(self):
-        """Coroutine to wait until service is closed."""
-        raise NotImplementedError
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, *exc):
-        self.close()
-        await self.wait_closed()
-
-
-class AbstractEventLoop:
-    """Abstract event loop."""
-
-    # Running and stopping the event loop.
-
-    def run_forever(self):
-        """Run the event loop until stop() is called."""
-        raise NotImplementedError
-
-    def run_until_complete(self, future):
-        """Run the event loop until a Future is done.
-
-        Return the Future's result, or raise its exception.
-        """
-        raise NotImplementedError
-
-    def stop(self):
-        """Stop the event loop as soon as reasonable.
-
-        Exactly how soon that is may depend on the implementation, but
-        no more I/O callbacks should be scheduled.
-        """
-        raise NotImplementedError
-
-    def is_running(self):
-        """Return whether the event loop is currently running."""
-        raise NotImplementedError
-
-    def is_closed(self):
-        """Returns True if the event loop was closed."""
-        raise NotImplementedError
-
-    def close(self):
-        """Close the loop.
-
-        The loop should not be running.
-
-        This is idempotent and irreversible.
-
-        No other methods should be called after this one.
-        """
-        raise NotImplementedError
-
-    async def shutdown_asyncgens(self):
-        """Shutdown all active asynchronous generators."""
-        raise NotImplementedError
-
-    # Methods scheduling callbacks.  All these return Handles.
-
-    def _timer_handle_cancelled(self, handle):
-        """Notification that a TimerHandle has been cancelled."""
-        raise NotImplementedError
-
-    def call_soon(self, callback, *args):
-        return self.call_later(0, callback, *args)
-
-    def call_later(self, delay, callback, *args):
-        raise NotImplementedError
-
-    def call_at(self, when, callback, *args):
-        raise NotImplementedError
-
-    def time(self):
-        raise NotImplementedError
-
-    def create_future(self):
-        raise NotImplementedError
-
-    # Method scheduling a coroutine object: create a task.
-
-    def create_task(self, coro):
-        raise NotImplementedError
-
-    # Methods for interacting with threads.
-
-    def call_soon_threadsafe(self, callback, *args):
-        raise NotImplementedError
-
-    async def run_in_executor(self, executor, func, *args):
-        raise NotImplementedError
-
-    def set_default_executor(self, executor):
-        raise NotImplementedError
-
-    # Network I/O methods returning Futures.
-
-    async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
-        raise NotImplementedError
-
-    async def getnameinfo(self, sockaddr, flags=0):
-        raise NotImplementedError
-
-    async def create_connection(
-        self,
-        protocol_factory,
-        host=None,
-        port=None,
-        *,
-        ssl=None,
-        family=0,
-        proto=0,
-        flags=0,
-        sock=None,
-        local_addr=None,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        raise NotImplementedError
-
-    async def create_server(
-        self,
-        protocol_factory,
-        host=None,
-        port=None,
-        *,
-        family=socket.AF_UNSPEC,
-        flags=socket.AI_PASSIVE,
-        sock=None,
-        backlog=100,
-        ssl=None,
-        reuse_address=None,
-        reuse_port=None,
-        ssl_handshake_timeout=None,
-        start_serving=True,
-    ):
-        """A coroutine which creates a TCP server bound to host and port.
-
-        The return value is a Server object which can be used to stop
-        the service.
-
-        If host is an empty string or None all interfaces are assumed
-        and a list of multiple sockets will be returned (most likely
-        one for IPv4 and another one for IPv6). The host parameter can also be
-        a sequence (e.g. list) of hosts to bind to.
-
-        family can be set to either AF_INET or AF_INET6 to force the
-        socket to use IPv4 or IPv6. If not set it will be determined
-        from host (defaults to AF_UNSPEC).
-
-        flags is a bitmask for getaddrinfo().
-
-        sock can optionally be specified in order to use a preexisting
-        socket object.
-
-        backlog is the maximum number of queued connections passed to
-        listen() (defaults to 100).
-
-        ssl can be set to an SSLContext to enable SSL over the
-        accepted connections.
-
-        reuse_address tells the kernel to reuse a local socket in
-        TIME_WAIT state, without waiting for its natural timeout to
-        expire. If not specified will automatically be set to True on
-        UNIX.
-
-        reuse_port tells the kernel to allow this endpoint to be bound to
-        the same port as other existing endpoints are bound to, so long as
-        they all set this flag when being created. This option is not
-        supported on Windows.
-
-        ssl_handshake_timeout is the time in seconds that an SSL server
-        will wait for completion of the SSL handshake before aborting the
-        connection. Default is 60s.
-
-        start_serving set to True (default) causes the created server
-        to start accepting connections immediately.  When set to False,
-        the user should await Server.start_serving() or Server.serve_forever()
-        to make the server to start accepting connections.
-        """
-        raise NotImplementedError
-
-    async def sendfile(self, transport, file, offset=0, count=None, *, fallback=True):
-        """Send a file through a transport.
-
-        Return an amount of sent bytes.
-        """
-        raise NotImplementedError
-
-    async def start_tls(
-        self,
-        transport,
-        protocol,
-        sslcontext,
-        *,
-        server_side=False,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        """Upgrade a transport to TLS.
-
-        Return a new transport that *protocol* should start using
-        immediately.
-        """
-        raise NotImplementedError
-
-    async def create_unix_connection(
-        self,
-        protocol_factory,
-        path=None,
-        *,
-        ssl=None,
-        sock=None,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        raise NotImplementedError
-
-    async def create_unix_server(
-        self,
-        protocol_factory,
-        path=None,
-        *,
-        sock=None,
-        backlog=100,
-        ssl=None,
-        ssl_handshake_timeout=None,
-        start_serving=True,
-    ):
-        """A coroutine which creates a UNIX Domain Socket server.
-
-        The return value is a Server object, which can be used to stop
-        the service.
-
-        path is a str, representing a file systsem path to bind the
-        server socket to.
-
-        sock can optionally be specified in order to use a preexisting
-        socket object.
-
-        backlog is the maximum number of queued connections passed to
-        listen() (defaults to 100).
-
-        ssl can be set to an SSLContext to enable SSL over the
-        accepted connections.
-
-        ssl_handshake_timeout is the time in seconds that an SSL server
-        will wait for the SSL handshake to complete (defaults to 60s).
-
-        start_serving set to True (default) causes the created server
-        to start accepting connections immediately.  When set to False,
-        the user should await Server.start_serving() or Server.serve_forever()
-        to make the server to start accepting connections.
-        """
-        raise NotImplementedError
-
-    async def create_datagram_endpoint(
-        self,
-        protocol_factory,
-        local_addr=None,
-        remote_addr=None,
-        *,
-        family=0,
-        proto=0,
-        flags=0,
-        reuse_address=None,
-        reuse_port=None,
-        allow_broadcast=None,
-        sock=None,
-    ):
-        """A coroutine which creates a datagram endpoint.
-
-        This method will try to establish the endpoint in the background.
-        When successful, the coroutine returns a (transport, protocol) pair.
-
-        protocol_factory must be a callable returning a protocol instance.
-
-        socket family AF_INET, socket.AF_INET6 or socket.AF_UNIX depending on
-        host (or family if specified), socket type SOCK_DGRAM.
-
-        reuse_address tells the kernel to reuse a local socket in
-        TIME_WAIT state, without waiting for its natural timeout to
-        expire. If not specified it will automatically be set to True on
-        UNIX.
-
-        reuse_port tells the kernel to allow this endpoint to be bound to
-        the same port as other existing endpoints are bound to, so long as
-        they all set this flag when being created. This option is not
-        supported on Windows and some UNIX's. If the
-        :py:data:`~socket.SO_REUSEPORT` constant is not defined then this
-        capability is unsupported.
-
-        allow_broadcast tells the kernel to allow this endpoint to send
-        messages to the broadcast address.
-
-        sock can optionally be specified in order to use a preexisting
-        socket object.
-        """
-        raise NotImplementedError
-
-    # Pipes and subprocesses.
-
-    async def connect_read_pipe(self, protocol_factory, pipe):
-        """Register read pipe in event loop. Set the pipe to non-blocking mode.
-
-        protocol_factory should instantiate object with Protocol interface.
-        pipe is a file-like object.
-        Return pair (transport, protocol), where transport supports the
-        ReadTransport interface."""
-        # The reason to accept file-like object instead of just file descriptor
-        # is: we need to own pipe and close it at transport finishing
-        # Can got complicated errors if pass f.fileno(),
-        # close fd in pipe transport then close f and vise versa.
-        raise NotImplementedError
-
-    async def connect_write_pipe(self, protocol_factory, pipe):
-        """Register write pipe in event loop.
-
-        protocol_factory should instantiate object with BaseProtocol interface.
-        Pipe is file-like object already switched to nonblocking.
-        Return pair (transport, protocol), where transport support
-        WriteTransport interface."""
-        # The reason to accept file-like object instead of just file descriptor
-        # is: we need to own pipe and close it at transport finishing
-        # Can got complicated errors if pass f.fileno(),
-        # close fd in pipe transport then close f and vise versa.
-        raise NotImplementedError
-
-    async def subprocess_shell(
-        self,
-        protocol_factory,
-        cmd,
-        *,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        **kwargs,
-    ):
-        raise NotImplementedError
-
-    async def subprocess_exec(
-        self,
-        protocol_factory,
-        *args,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        **kwargs,
-    ):
-        raise NotImplementedError
-
-    # Ready-based callback registration methods.
-    # The add_*() methods return None.
-    # The remove_*() methods return True if something was removed,
-    # False if there was nothing to delete.
-
-    def add_reader(self, fd, callback, *args):
-        raise NotImplementedError
-
-    def remove_reader(self, fd):
-        raise NotImplementedError
-
-    def add_writer(self, fd, callback, *args):
-        raise NotImplementedError
-
-    def remove_writer(self, fd):
-        raise NotImplementedError
-
-    # Completion based I/O methods returning Futures.
-
-    async def sock_recv(self, sock, nbytes):
-        raise NotImplementedError
-
-    async def sock_recv_into(self, sock, buf):
-        raise NotImplementedError
-
-    async def sock_sendall(self, sock, data):
-        raise NotImplementedError
-
-    async def sock_connect(self, sock, address):
-        raise NotImplementedError
-
-    async def sock_accept(self, sock):
-        raise NotImplementedError
-
-    async def sock_sendfile(self, sock, file, offset=0, count=None, *, fallback=None):
-        raise NotImplementedError
-
-    # Signal handling.
-
-    def add_signal_handler(self, sig, callback, *args):
-        raise NotImplementedError
-
-    def remove_signal_handler(self, sig):
-        raise NotImplementedError
-
-    # Task factory.
-
-    def set_task_factory(self, factory):
-        raise NotImplementedError
-
-    def get_task_factory(self):
-        raise NotImplementedError
-
-    # Error handlers.
-
-    def get_exception_handler(self):
-        raise NotImplementedError
-
-    def set_exception_handler(self, handler):
-        raise NotImplementedError
-
-    def default_exception_handler(self, context):
-        raise NotImplementedError
-
-    def call_exception_handler(self, context):
-        raise NotImplementedError
-
-    # Debug flag management.
-
-    def get_debug(self):
-        raise NotImplementedError
-
-    def set_debug(self, enabled):
-        raise NotImplementedError
-
-
-class AbstractEventLoopPolicy:
-    """Abstract policy for accessing the event loop."""
-
-    def get_event_loop(self):
-        """Get the event loop for the current context.
-
-        Returns an event loop object implementing the BaseEventLoop interface,
-        or raises an exception in case no event loop has been set for the
-        current context and the current policy does not specify to create one.
-
-        It should never return None."""
-        raise NotImplementedError
-
-    def set_event_loop(self, loop):
-        """Set the event loop for the current context to loop."""
-        raise NotImplementedError
-
-    def new_event_loop(self):
-        """Create and return a new event loop object according to this
-        policy's rules. If there's need to set this loop as the event loop for
-        the current context, set_event_loop must be called explicitly."""
-        raise NotImplementedError
-
-    # Child processes handling (Unix only).
-
-    def get_child_watcher(self):
-        "Get the watcher for child processes."
-        raise NotImplementedError
-
-    def set_child_watcher(self, watcher):
-        """Set the watcher for child processes."""
-        raise NotImplementedError
-
-
-class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy):
-    """Default policy implementation for accessing the event loop.
-
-    In this policy, each thread has its own event loop.  However, we
-    only automatically create an event loop by default for the main
-    thread; other threads by default have no event loop.
-
-    Other policies may have different rules (e.g. a single global
-    event loop, or automatically creating an event loop per thread, or
-    using some other notion of context to which an event loop is
-    associated).
-    """
-
-    _loop_factory = None
-
-    class _Local(threading.local):
-        _loop = None
-        _set_called = False
-
-    def __init__(self):
-        self._local = self._Local()
-
-    def get_event_loop(self):
-        """Get the event loop for the current context.
-
-        Returns an instance of EventLoop or raises an exception.
-        """
-        if (
-            self._local._loop is None
-            and not self._local._set_called
-            and isinstance(threading.current_thread(), threading._MainThread)
-        ):
-            self.set_event_loop(self.new_event_loop())
-
-        if self._local._loop is None:
-            raise RuntimeError(
-                "There is no current event loop in thread %r."
-                % threading.current_thread().name
-            )
-
-        return self._local._loop
-
-    def set_event_loop(self, loop):
-        """Set the event loop."""
-        self._local._set_called = True
-        assert loop is None or isinstance(loop, AbstractEventLoop)
-        self._local._loop = loop
-
-    def new_event_loop(self):
-        """Create a new event loop.
-
-        You must call set_event_loop() to make this the current event
-        loop.
-        """
-        return self._loop_factory()
-
-
-# Event loop policy.  The policy itself is always global, even if the
-# policy's rules say that there is an event loop per thread (or other
-# notion of context).  The default policy is installed by the first
-# call to get_event_loop_policy().
-_event_loop_policy = None
-
-# Lock for protecting the on-the-fly creation of the event loop policy.
-_lock = threading.Lock()
-
-
-# A TLS for the running event loop, used by _get_running_loop.
-class _RunningLoop(threading.local):
-    loop_pid = (None, None)
-
-
-_running_loop = _RunningLoop()
-
-
-def get_running_loop():
-    """Return the running event loop.  Raise a RuntimeError if there is none.
-
-    This function is thread-specific.
-    """
-    # NOTE: this function is implemented in C (see _asynciomodule.c)
-    loop = _get_running_loop()
-    if loop is None:
-        raise RuntimeError("no running event loop")
-    return loop
-
-
-def _get_running_loop():
-    """Return the running event loop or None.
-
-    This is a low-level function intended to be used by event loops.
-    This function is thread-specific.
-    """
-    # NOTE: this function is implemented in C (see _asynciomodule.c)
-    running_loop, pid = _running_loop.loop_pid
-    if running_loop is not None and pid == os.getpid():
-        return running_loop
-
-
-def _set_running_loop(loop):
-    """Set the running event loop.
-
-    This is a low-level function intended to be used by event loops.
-    This function is thread-specific.
-    """
-    # NOTE: this function is implemented in C (see _asynciomodule.c)
-    _running_loop.loop_pid = (loop, os.getpid())
-
-
-def _init_event_loop_policy():
-    global _event_loop_policy
-    with _lock:
-        if _event_loop_policy is None:  # pragma: no branch
-            from . import DefaultEventLoopPolicy
-
-            _event_loop_policy = DefaultEventLoopPolicy()
-
-
-def get_event_loop_policy():
-    """Get the current event loop policy."""
-    if _event_loop_policy is None:
-        _init_event_loop_policy()
-    return _event_loop_policy
-
-
-def set_event_loop_policy(policy):
-    """Set the current event loop policy.
-
-    If policy is None, the default policy is restored."""
-    global _event_loop_policy
-    assert policy is None or isinstance(policy, AbstractEventLoopPolicy)
-    _event_loop_policy = policy
-
-
-def get_event_loop():
-    """Return an asyncio event loop.
-
-    When called from a coroutine or a callback (e.g. scheduled with call_soon
-    or similar API), this function will always return the running event loop.
-
-    If there is no running event loop set, the function will return
-    the result of `get_event_loop_policy().get_event_loop()` call.
-    """
-    # NOTE: this function is implemented in C (see _asynciomodule.c)
-    current_loop = _get_running_loop()
-    if current_loop is not None:
-        return current_loop
-    return get_event_loop_policy().get_event_loop()
-
-
-def set_event_loop(loop):
-    """Equivalent to calling get_event_loop_policy().set_event_loop(loop)."""
-    get_event_loop_policy().set_event_loop(loop)
-
-
-def new_event_loop():
-    """Equivalent to calling get_event_loop_policy().new_event_loop()."""
-    return get_event_loop_policy().new_event_loop()
-
-
-def get_child_watcher():
-    """Equivalent to calling get_event_loop_policy().get_child_watcher()."""
-    return get_event_loop_policy().get_child_watcher()
-
-
-def set_child_watcher(watcher):
-    """Equivalent to calling
-    get_event_loop_policy().set_child_watcher(watcher)."""
-    return get_event_loop_policy().set_child_watcher(watcher)
-
-
-# Alias pure-Python implementations for testing purposes.
-_py__get_running_loop = _get_running_loop
-_py__set_running_loop = _set_running_loop
-_py_get_running_loop = get_running_loop
-_py_get_event_loop = get_event_loop
-
-
-try:
-    # get_event_loop() is one of the most frequently called
-    # functions in asyncio.  Pure Python implementation is
-    # about 4 times slower than C-accelerated.
-    from _asyncio import (
-        _get_running_loop,
-        _set_running_loop,
-        get_running_loop,
-        get_event_loop,
-    )
-except ImportError:
-    pass
-else:
-    # Alias C implementations for testing purposes.
-    _c__get_running_loop = _get_running_loop
-    _c__set_running_loop = _set_running_loop
-    _c_get_running_loop = get_running_loop
-    _c_get_event_loop = get_event_loop
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/format_helpers.py b/addon/globalPlugins/spellcheck/libs/asyncio/format_helpers.py
deleted file mode 100644
index 3fc181b..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/format_helpers.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import functools
-import inspect
-import reprlib
-import sys
-import traceback
-
-from . import constants
-
-
-def _get_function_source(func):
-    func = inspect.unwrap(func)
-    if inspect.isfunction(func):
-        code = func.__code__
-        return (code.co_filename, code.co_firstlineno)
-    if isinstance(func, functools.partial):
-        return _get_function_source(func.func)
-    if isinstance(func, functools.partialmethod):
-        return _get_function_source(func.func)
-    return None
-
-
-def _format_callback_source(func, args):
-    func_repr = _format_callback(func, args, None)
-    source = _get_function_source(func)
-    if source:
-        func_repr += f" at {source[0]}:{source[1]}"
-    return func_repr
-
-
-def _format_args_and_kwargs(args, kwargs):
-    """Format function arguments and keyword arguments.
-
-    Special case for a single parameter: ('hello',) is formatted as ('hello').
-    """
-    # use reprlib to limit the length of the output
-    items = []
-    if args:
-        items.extend(reprlib.repr(arg) for arg in args)
-    if kwargs:
-        items.extend(f"{k}={reprlib.repr(v)}" for k, v in kwargs.items())
-    return "({})".format(", ".join(items))
-
-
-def _format_callback(func, args, kwargs, suffix=""):
-    if isinstance(func, functools.partial):
-        suffix = _format_args_and_kwargs(args, kwargs) + suffix
-        return _format_callback(func.func, func.args, func.keywords, suffix)
-
-    if hasattr(func, "__qualname__") and func.__qualname__:
-        func_repr = func.__qualname__
-    elif hasattr(func, "__name__") and func.__name__:
-        func_repr = func.__name__
-    else:
-        func_repr = repr(func)
-
-    func_repr += _format_args_and_kwargs(args, kwargs)
-    if suffix:
-        func_repr += suffix
-    return func_repr
-
-
-def extract_stack(f=None, limit=None):
-    """Replacement for traceback.extract_stack() that only does the
-    necessary work for asyncio debug mode.
-    """
-    if f is None:
-        f = sys._getframe().f_back
-    if limit is None:
-        # Limit the amount of work to a reasonable amount, as extract_stack()
-        # can be called for each coroutine and future in debug mode.
-        limit = constants.DEBUG_STACK_DEPTH
-    stack = traceback.StackSummary.extract(
-        traceback.walk_stack(f), limit=limit, lookup_lines=False
-    )
-    stack.reverse()
-    return stack
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/futures.py b/addon/globalPlugins/spellcheck/libs/asyncio/futures.py
deleted file mode 100644
index ee455a3..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/futures.py
+++ /dev/null
@@ -1,391 +0,0 @@
-"""A Future class similar to the one in PEP 3148."""
-
-__all__ = (
-    "CancelledError",
-    "TimeoutError",
-    "InvalidStateError",
-    "Future",
-    "wrap_future",
-    "isfuture",
-)
-
-import concurrent.futures
-import contextvars
-import logging
-import sys
-
-from . import base_futures
-from . import events
-from . import format_helpers
-
-
-CancelledError = base_futures.CancelledError
-InvalidStateError = base_futures.InvalidStateError
-TimeoutError = base_futures.TimeoutError
-isfuture = base_futures.isfuture
-
-
-_PENDING = base_futures._PENDING
-_CANCELLED = base_futures._CANCELLED
-_FINISHED = base_futures._FINISHED
-
-
-STACK_DEBUG = logging.DEBUG - 1  # heavy-duty debugging
-
-
-class Future:
-    """This class is *almost* compatible with concurrent.futures.Future.
-
-    Differences:
-
-    - This class is not thread-safe.
-
-    - result() and exception() do not take a timeout argument and
-      raise an exception when the future isn't done yet.
-
-    - Callbacks registered with add_done_callback() are always called
-      via the event loop's call_soon().
-
-    - This class is not compatible with the wait() and as_completed()
-      methods in the concurrent.futures package.
-
-    (In Python 3.4 or later we may be able to unify the implementations.)
-    """
-
-    # Class variables serving as defaults for instance variables.
-    _state = _PENDING
-    _result = None
-    _exception = None
-    _loop = None
-    _source_traceback = None
-
-    # This field is used for a dual purpose:
-    # - Its presence is a marker to declare that a class implements
-    #   the Future protocol (i.e. is intended to be duck-type compatible).
-    #   The value must also be not-None, to enable a subclass to declare
-    #   that it is not compatible by setting this to None.
-    # - It is set by __iter__() below so that Task._step() can tell
-    #   the difference between
-    #   `await Future()` or`yield from Future()` (correct) vs.
-    #   `yield Future()` (incorrect).
-    _asyncio_future_blocking = False
-
-    __log_traceback = False
-
-    def __init__(self, *, loop=None):
-        """Initialize the future.
-
-        The optional event_loop argument allows explicitly setting the event
-        loop object used by the future. If it's not provided, the future uses
-        the default event loop.
-        """
-        if loop is None:
-            self._loop = events.get_event_loop()
-        else:
-            self._loop = loop
-        self._callbacks = []
-        if self._loop.get_debug():
-            self._source_traceback = format_helpers.extract_stack(sys._getframe(1))
-
-    _repr_info = base_futures._future_repr_info
-
-    def __repr__(self):
-        return "<{} {}>".format(self.__class__.__name__, " ".join(self._repr_info()))
-
-    def __del__(self):
-        if not self.__log_traceback:
-            # set_exception() was not called, or result() or exception()
-            # has consumed the exception
-            return
-        exc = self._exception
-        context = {
-            "message": f"{self.__class__.__name__} exception was never retrieved",
-            "exception": exc,
-            "future": self,
-        }
-        if self._source_traceback:
-            context["source_traceback"] = self._source_traceback
-        self._loop.call_exception_handler(context)
-
-    @property
-    def _log_traceback(self):
-        return self.__log_traceback
-
-    @_log_traceback.setter
-    def _log_traceback(self, val):
-        if bool(val):
-            raise ValueError("_log_traceback can only be set to False")
-        self.__log_traceback = False
-
-    def get_loop(self):
-        """Return the event loop the Future is bound to."""
-        loop = self._loop
-        if loop is None:
-            raise RuntimeError("Future object is not initialized.")
-        return loop
-
-    def cancel(self):
-        """Cancel the future and schedule callbacks.
-
-        If the future is already done or cancelled, return False.  Otherwise,
-        change the future's state to cancelled, schedule the callbacks and
-        return True.
-        """
-        self.__log_traceback = False
-        if self._state != _PENDING:
-            return False
-        self._state = _CANCELLED
-        self.__schedule_callbacks()
-        return True
-
-    def __schedule_callbacks(self):
-        """Internal: Ask the event loop to call all callbacks.
-
-        The callbacks are scheduled to be called as soon as possible. Also
-        clears the callback list.
-        """
-        callbacks = self._callbacks[:]
-        if not callbacks:
-            return
-
-        self._callbacks[:] = []
-        for callback, ctx in callbacks:
-            self._loop.call_soon(callback, self, context=ctx)
-
-    def cancelled(self):
-        """Return True if the future was cancelled."""
-        return self._state == _CANCELLED
-
-    # Don't implement running(); see http://bugs.python.org/issue18699
-
-    def done(self):
-        """Return True if the future is done.
-
-        Done means either that a result / exception are available, or that the
-        future was cancelled.
-        """
-        return self._state != _PENDING
-
-    def result(self):
-        """Return the result this future represents.
-
-        If the future has been cancelled, raises CancelledError.  If the
-        future's result isn't yet available, raises InvalidStateError.  If
-        the future is done and has an exception set, this exception is raised.
-        """
-        if self._state == _CANCELLED:
-            raise CancelledError
-        if self._state != _FINISHED:
-            raise InvalidStateError("Result is not ready.")
-        self.__log_traceback = False
-        if self._exception is not None:
-            raise self._exception
-        return self._result
-
-    def exception(self):
-        """Return the exception that was set on this future.
-
-        The exception (or None if no exception was set) is returned only if
-        the future is done.  If the future has been cancelled, raises
-        CancelledError.  If the future isn't done yet, raises
-        InvalidStateError.
-        """
-        if self._state == _CANCELLED:
-            raise CancelledError
-        if self._state != _FINISHED:
-            raise InvalidStateError("Exception is not set.")
-        self.__log_traceback = False
-        return self._exception
-
-    def add_done_callback(self, fn, *, context=None):
-        """Add a callback to be run when the future becomes done.
-
-        The callback is called with a single argument - the future object. If
-        the future is already done when this is called, the callback is
-        scheduled with call_soon.
-        """
-        if self._state != _PENDING:
-            self._loop.call_soon(fn, self, context=context)
-        else:
-            if context is None:
-                context = contextvars.copy_context()
-            self._callbacks.append((fn, context))
-
-    # New method not in PEP 3148.
-
-    def remove_done_callback(self, fn):
-        """Remove all instances of a callback from the "call when done" list.
-
-        Returns the number of callbacks removed.
-        """
-        filtered_callbacks = [(f, ctx) for (f, ctx) in self._callbacks if f != fn]
-        removed_count = len(self._callbacks) - len(filtered_callbacks)
-        if removed_count:
-            self._callbacks[:] = filtered_callbacks
-        return removed_count
-
-    # So-called internal methods (note: no set_running_or_notify_cancel()).
-
-    def set_result(self, result):
-        """Mark the future done and set its result.
-
-        If the future is already done when this method is called, raises
-        InvalidStateError.
-        """
-        if self._state != _PENDING:
-            raise InvalidStateError("{}: {!r}".format(self._state, self))
-        self._result = result
-        self._state = _FINISHED
-        self.__schedule_callbacks()
-
-    def set_exception(self, exception):
-        """Mark the future done and set an exception.
-
-        If the future is already done when this method is called, raises
-        InvalidStateError.
-        """
-        if self._state != _PENDING:
-            raise InvalidStateError("{}: {!r}".format(self._state, self))
-        if isinstance(exception, type):
-            exception = exception()
-        if type(exception) is StopIteration:
-            raise TypeError(
-                "StopIteration interacts badly with generators "
-                "and cannot be raised into a Future"
-            )
-        self._exception = exception
-        self._state = _FINISHED
-        self.__schedule_callbacks()
-        self.__log_traceback = True
-
-    def __await__(self):
-        if not self.done():
-            self._asyncio_future_blocking = True
-            yield self  # This tells Task to wait for completion.
-        if not self.done():
-            raise RuntimeError("await wasn't used with future")
-        return self.result()  # May raise too.
-
-    __iter__ = __await__  # make compatible with 'yield from'.
-
-
-# Needed for testing purposes.
-_PyFuture = Future
-
-
-def _get_loop(fut):
-    # Tries to call Future.get_loop() if it's available.
-    # Otherwise fallbacks to using the old '_loop' property.
-    try:
-        get_loop = fut.get_loop
-    except AttributeError:
-        pass
-    else:
-        return get_loop()
-    return fut._loop
-
-
-def _set_result_unless_cancelled(fut, result):
-    """Helper setting the result only if the future was not cancelled."""
-    if fut.cancelled():
-        return
-    fut.set_result(result)
-
-
-def _set_concurrent_future_state(concurrent, source):
-    """Copy state from a future to a concurrent.futures.Future."""
-    assert source.done()
-    if source.cancelled():
-        concurrent.cancel()
-    if not concurrent.set_running_or_notify_cancel():
-        return
-    exception = source.exception()
-    if exception is not None:
-        concurrent.set_exception(exception)
-    else:
-        result = source.result()
-        concurrent.set_result(result)
-
-
-def _copy_future_state(source, dest):
-    """Internal helper to copy state from another Future.
-
-    The other Future may be a concurrent.futures.Future.
-    """
-    assert source.done()
-    if dest.cancelled():
-        return
-    assert not dest.done()
-    if source.cancelled():
-        dest.cancel()
-    else:
-        exception = source.exception()
-        if exception is not None:
-            dest.set_exception(exception)
-        else:
-            result = source.result()
-            dest.set_result(result)
-
-
-def _chain_future(source, destination):
-    """Chain two futures so that when one completes, so does the other.
-
-    The result (or exception) of source will be copied to destination.
-    If destination is cancelled, source gets cancelled too.
-    Compatible with both asyncio.Future and concurrent.futures.Future.
-    """
-    if not isfuture(source) and not isinstance(source, concurrent.futures.Future):
-        raise TypeError("A future is required for source argument")
-    if not isfuture(destination) and not isinstance(
-        destination, concurrent.futures.Future
-    ):
-        raise TypeError("A future is required for destination argument")
-    source_loop = _get_loop(source) if isfuture(source) else None
-    dest_loop = _get_loop(destination) if isfuture(destination) else None
-
-    def _set_state(future, other):
-        if isfuture(future):
-            _copy_future_state(other, future)
-        else:
-            _set_concurrent_future_state(future, other)
-
-    def _call_check_cancel(destination):
-        if destination.cancelled():
-            if source_loop is None or source_loop is dest_loop:
-                source.cancel()
-            else:
-                source_loop.call_soon_threadsafe(source.cancel)
-
-    def _call_set_state(source):
-        if destination.cancelled() and dest_loop is not None and dest_loop.is_closed():
-            return
-        if dest_loop is None or dest_loop is source_loop:
-            _set_state(destination, source)
-        else:
-            dest_loop.call_soon_threadsafe(_set_state, destination, source)
-
-    destination.add_done_callback(_call_check_cancel)
-    source.add_done_callback(_call_set_state)
-
-
-def wrap_future(future, *, loop=None):
-    """Wrap concurrent.futures.Future object."""
-    if isfuture(future):
-        return future
-    assert isinstance(
-        future, concurrent.futures.Future
-    ), f"concurrent.futures.Future is expected, got {future!r}"
-    if loop is None:
-        loop = events.get_event_loop()
-    new_future = loop.create_future()
-    _chain_future(future, new_future)
-    return new_future
-
-
-try:
-    import _asyncio
-except ImportError:
-    pass
-else:
-    # _CFuture is needed for tests.
-    Future = _CFuture = _asyncio.Future
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/locks.py b/addon/globalPlugins/spellcheck/libs/asyncio/locks.py
deleted file mode 100644
index 617f843..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/locks.py
+++ /dev/null
@@ -1,510 +0,0 @@
-"""Synchronization primitives."""
-
-__all__ = ("Lock", "Event", "Condition", "Semaphore", "BoundedSemaphore")
-
-import collections
-import warnings
-
-from . import events
-from . import futures
-from .coroutines import coroutine
-
-
-class _ContextManager:
-    """Context manager.
-
-    This enables the following idiom for acquiring and releasing a
-    lock around a block:
-
-        with (yield from lock):
-            <block>
-
-    while failing loudly when accidentally using:
-
-        with lock:
-            <block>
-
-    Deprecated, use 'async with' statement:
-        async with lock:
-            <block>
-    """
-
-    def __init__(self, lock):
-        self._lock = lock
-
-    def __enter__(self):
-        # We have no use for the "as ..."  clause in the with
-        # statement for locks.
-        return None
-
-    def __exit__(self, *args):
-        try:
-            self._lock.release()
-        finally:
-            self._lock = None  # Crudely prevent reuse.
-
-
-class _ContextManagerMixin:
-    def __enter__(self):
-        raise RuntimeError('"yield from" should be used as context manager expression')
-
-    def __exit__(self, *args):
-        # This must exist because __enter__ exists, even though that
-        # always raises; that's how the with-statement works.
-        pass
-
-    @coroutine
-    def __iter__(self):
-        # This is not a coroutine.  It is meant to enable the idiom:
-        #
-        #     with (yield from lock):
-        #         <block>
-        #
-        # as an alternative to:
-        #
-        #     yield from lock.acquire()
-        #     try:
-        #         <block>
-        #     finally:
-        #         lock.release()
-        # Deprecated, use 'async with' statement:
-        #     async with lock:
-        #         <block>
-        warnings.warn(
-            "'with (yield from lock)' is deprecated " "use 'async with lock' instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        yield from self.acquire()
-        return _ContextManager(self)
-
-    async def __acquire_ctx(self):
-        await self.acquire()
-        return _ContextManager(self)
-
-    def __await__(self):
-        warnings.warn(
-            "'with await lock' is deprecated " "use 'async with lock' instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        # To make "with await lock" work.
-        return self.__acquire_ctx().__await__()
-
-    async def __aenter__(self):
-        await self.acquire()
-        # We have no use for the "as ..."  clause in the with
-        # statement for locks.
-        return None
-
-    async def __aexit__(self, exc_type, exc, tb):
-        self.release()
-
-
-class Lock(_ContextManagerMixin):
-    """Primitive lock objects.
-
-    A primitive lock is a synchronization primitive that is not owned
-    by a particular coroutine when locked.  A primitive lock is in one
-    of two states, 'locked' or 'unlocked'.
-
-    It is created in the unlocked state.  It has two basic methods,
-    acquire() and release().  When the state is unlocked, acquire()
-    changes the state to locked and returns immediately.  When the
-    state is locked, acquire() blocks until a call to release() in
-    another coroutine changes it to unlocked, then the acquire() call
-    resets it to locked and returns.  The release() method should only
-    be called in the locked state; it changes the state to unlocked
-    and returns immediately.  If an attempt is made to release an
-    unlocked lock, a RuntimeError will be raised.
-
-    When more than one coroutine is blocked in acquire() waiting for
-    the state to turn to unlocked, only one coroutine proceeds when a
-    release() call resets the state to unlocked; first coroutine which
-    is blocked in acquire() is being processed.
-
-    acquire() is a coroutine and should be called with 'await'.
-
-    Locks also support the asynchronous context management protocol.
-    'async with lock' statement should be used.
-
-    Usage:
-
-        lock = Lock()
-        ...
-        await lock.acquire()
-        try:
-            ...
-        finally:
-            lock.release()
-
-    Context manager usage:
-
-        lock = Lock()
-        ...
-        async with lock:
-             ...
-
-    Lock objects can be tested for locking state:
-
-        if not lock.locked():
-           await lock.acquire()
-        else:
-           # lock is acquired
-           ...
-
-    """
-
-    def __init__(self, *, loop=None):
-        self._waiters = collections.deque()
-        self._locked = False
-        if loop is not None:
-            self._loop = loop
-        else:
-            self._loop = events.get_event_loop()
-
-    def __repr__(self):
-        res = super().__repr__()
-        extra = "locked" if self._locked else "unlocked"
-        if self._waiters:
-            extra = f"{extra}, waiters:{len(self._waiters)}"
-        return f"<{res[1:-1]} [{extra}]>"
-
-    def locked(self):
-        """Return True if lock is acquired."""
-        return self._locked
-
-    async def acquire(self):
-        """Acquire a lock.
-
-        This method blocks until the lock is unlocked, then sets it to
-        locked and returns True.
-        """
-        if not self._locked and all(w.cancelled() for w in self._waiters):
-            self._locked = True
-            return True
-
-        fut = self._loop.create_future()
-        self._waiters.append(fut)
-
-        # Finally block should be called before the CancelledError
-        # handling as we don't want CancelledError to call
-        # _wake_up_first() and attempt to wake up itself.
-        try:
-            try:
-                await fut
-            finally:
-                self._waiters.remove(fut)
-        except futures.CancelledError:
-            if not self._locked:
-                self._wake_up_first()
-            raise
-
-        self._locked = True
-        return True
-
-    def release(self):
-        """Release a lock.
-
-        When the lock is locked, reset it to unlocked, and return.
-        If any other coroutines are blocked waiting for the lock to become
-        unlocked, allow exactly one of them to proceed.
-
-        When invoked on an unlocked lock, a RuntimeError is raised.
-
-        There is no return value.
-        """
-        if self._locked:
-            self._locked = False
-            self._wake_up_first()
-        else:
-            raise RuntimeError("Lock is not acquired.")
-
-    def _wake_up_first(self):
-        """Wake up the first waiter if it isn't done."""
-        try:
-            fut = next(iter(self._waiters))
-        except StopIteration:
-            return
-
-        # .done() necessarily means that a waiter will wake up later on and
-        # either take the lock, or, if it was cancelled and lock wasn't
-        # taken already, will hit this again and wake up a new waiter.
-        if not fut.done():
-            fut.set_result(True)
-
-
-class Event:
-    """Asynchronous equivalent to threading.Event.
-
-    Class implementing event objects. An event manages a flag that can be set
-    to true with the set() method and reset to false with the clear() method.
-    The wait() method blocks until the flag is true. The flag is initially
-    false.
-    """
-
-    def __init__(self, *, loop=None):
-        self._waiters = collections.deque()
-        self._value = False
-        if loop is not None:
-            self._loop = loop
-        else:
-            self._loop = events.get_event_loop()
-
-    def __repr__(self):
-        res = super().__repr__()
-        extra = "set" if self._value else "unset"
-        if self._waiters:
-            extra = f"{extra}, waiters:{len(self._waiters)}"
-        return f"<{res[1:-1]} [{extra}]>"
-
-    def is_set(self):
-        """Return True if and only if the internal flag is true."""
-        return self._value
-
-    def set(self):
-        """Set the internal flag to true. All coroutines waiting for it to
-        become true are awakened. Coroutine that call wait() once the flag is
-        true will not block at all.
-        """
-        if not self._value:
-            self._value = True
-
-            for fut in self._waiters:
-                if not fut.done():
-                    fut.set_result(True)
-
-    def clear(self):
-        """Reset the internal flag to false. Subsequently, coroutines calling
-        wait() will block until set() is called to set the internal flag
-        to true again."""
-        self._value = False
-
-    async def wait(self):
-        """Block until the internal flag is true.
-
-        If the internal flag is true on entry, return True
-        immediately.  Otherwise, block until another coroutine calls
-        set() to set the flag to true, then return True.
-        """
-        if self._value:
-            return True
-
-        fut = self._loop.create_future()
-        self._waiters.append(fut)
-        try:
-            await fut
-            return True
-        finally:
-            self._waiters.remove(fut)
-
-
-class Condition(_ContextManagerMixin):
-    """Asynchronous equivalent to threading.Condition.
-
-    This class implements condition variable objects. A condition variable
-    allows one or more coroutines to wait until they are notified by another
-    coroutine.
-
-    A new Lock object is created and used as the underlying lock.
-    """
-
-    def __init__(self, lock=None, *, loop=None):
-        if loop is not None:
-            self._loop = loop
-        else:
-            self._loop = events.get_event_loop()
-
-        if lock is None:
-            lock = Lock(loop=self._loop)
-        elif lock._loop is not self._loop:
-            raise ValueError("loop argument must agree with lock")
-
-        self._lock = lock
-        # Export the lock's locked(), acquire() and release() methods.
-        self.locked = lock.locked
-        self.acquire = lock.acquire
-        self.release = lock.release
-
-        self._waiters = collections.deque()
-
-    def __repr__(self):
-        res = super().__repr__()
-        extra = "locked" if self.locked() else "unlocked"
-        if self._waiters:
-            extra = f"{extra}, waiters:{len(self._waiters)}"
-        return f"<{res[1:-1]} [{extra}]>"
-
-    async def wait(self):
-        """Wait until notified.
-
-        If the calling coroutine has not acquired the lock when this
-        method is called, a RuntimeError is raised.
-
-        This method releases the underlying lock, and then blocks
-        until it is awakened by a notify() or notify_all() call for
-        the same condition variable in another coroutine.  Once
-        awakened, it re-acquires the lock and returns True.
-        """
-        if not self.locked():
-            raise RuntimeError("cannot wait on un-acquired lock")
-
-        self.release()
-        try:
-            fut = self._loop.create_future()
-            self._waiters.append(fut)
-            try:
-                await fut
-                return True
-            finally:
-                self._waiters.remove(fut)
-
-        finally:
-            # Must reacquire lock even if wait is cancelled
-            cancelled = False
-            while True:
-                try:
-                    await self.acquire()
-                    break
-                except futures.CancelledError:
-                    cancelled = True
-
-            if cancelled:
-                raise futures.CancelledError
-
-    async def wait_for(self, predicate):
-        """Wait until a predicate becomes true.
-
-        The predicate should be a callable which result will be
-        interpreted as a boolean value.  The final predicate value is
-        the return value.
-        """
-        result = predicate()
-        while not result:
-            await self.wait()
-            result = predicate()
-        return result
-
-    def notify(self, n=1):
-        """By default, wake up one coroutine waiting on this condition, if any.
-        If the calling coroutine has not acquired the lock when this method
-        is called, a RuntimeError is raised.
-
-        This method wakes up at most n of the coroutines waiting for the
-        condition variable; it is a no-op if no coroutines are waiting.
-
-        Note: an awakened coroutine does not actually return from its
-        wait() call until it can reacquire the lock. Since notify() does
-        not release the lock, its caller should.
-        """
-        if not self.locked():
-            raise RuntimeError("cannot notify on un-acquired lock")
-
-        idx = 0
-        for fut in self._waiters:
-            if idx >= n:
-                break
-
-            if not fut.done():
-                idx += 1
-                fut.set_result(False)
-
-    def notify_all(self):
-        """Wake up all threads waiting on this condition. This method acts
-        like notify(), but wakes up all waiting threads instead of one. If the
-        calling thread has not acquired the lock when this method is called,
-        a RuntimeError is raised.
-        """
-        self.notify(len(self._waiters))
-
-
-class Semaphore(_ContextManagerMixin):
-    """A Semaphore implementation.
-
-    A semaphore manages an internal counter which is decremented by each
-    acquire() call and incremented by each release() call. The counter
-    can never go below zero; when acquire() finds that it is zero, it blocks,
-    waiting until some other thread calls release().
-
-    Semaphores also support the context management protocol.
-
-    The optional argument gives the initial value for the internal
-    counter; it defaults to 1. If the value given is less than 0,
-    ValueError is raised.
-    """
-
-    def __init__(self, value=1, *, loop=None):
-        if value < 0:
-            raise ValueError("Semaphore initial value must be >= 0")
-        self._value = value
-        self._waiters = collections.deque()
-        if loop is not None:
-            self._loop = loop
-        else:
-            self._loop = events.get_event_loop()
-
-    def __repr__(self):
-        res = super().__repr__()
-        extra = "locked" if self.locked() else f"unlocked, value:{self._value}"
-        if self._waiters:
-            extra = f"{extra}, waiters:{len(self._waiters)}"
-        return f"<{res[1:-1]} [{extra}]>"
-
-    def _wake_up_next(self):
-        while self._waiters:
-            waiter = self._waiters.popleft()
-            if not waiter.done():
-                waiter.set_result(None)
-                return
-
-    def locked(self):
-        """Returns True if semaphore can not be acquired immediately."""
-        return self._value == 0
-
-    async def acquire(self):
-        """Acquire a semaphore.
-
-        If the internal counter is larger than zero on entry,
-        decrement it by one and return True immediately.  If it is
-        zero on entry, block, waiting until some other coroutine has
-        called release() to make it larger than 0, and then return
-        True.
-        """
-        while self._value <= 0:
-            fut = self._loop.create_future()
-            self._waiters.append(fut)
-            try:
-                await fut
-            except:
-                # See the similar code in Queue.get.
-                fut.cancel()
-                if self._value > 0 and not fut.cancelled():
-                    self._wake_up_next()
-                raise
-        self._value -= 1
-        return True
-
-    def release(self):
-        """Release a semaphore, incrementing the internal counter by one.
-        When it was zero on entry and another coroutine is waiting for it to
-        become larger than zero again, wake up that coroutine.
-        """
-        self._value += 1
-        self._wake_up_next()
-
-
-class BoundedSemaphore(Semaphore):
-    """A bounded semaphore implementation.
-
-    This raises ValueError in release() if it would increase the value
-    above the initial value.
-    """
-
-    def __init__(self, value=1, *, loop=None):
-        self._bound_value = value
-        super().__init__(value, loop=loop)
-
-    def release(self):
-        if self._value >= self._bound_value:
-            raise ValueError("BoundedSemaphore released too many times")
-        super().release()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/log.py b/addon/globalPlugins/spellcheck/libs/asyncio/log.py
deleted file mode 100644
index 23a7074..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/log.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""Logging configuration."""
-
-import logging
-
-
-# Name the logger after the package.
-logger = logging.getLogger(__package__)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/proactor_events.py b/addon/globalPlugins/spellcheck/libs/asyncio/proactor_events.py
deleted file mode 100644
index 91a529f..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/proactor_events.py
+++ /dev/null
@@ -1,724 +0,0 @@
-"""Event loop using a proactor and related classes.
-
-A proactor is a "notify-on-completion" multiplexer.  Currently a
-proactor is only implemented on Windows with IOCP.
-"""
-
-__all__ = ("BaseProactorEventLoop",)
-
-import io
-import os
-import socket
-import warnings
-
-from . import base_events
-from . import constants
-from . import events
-from . import futures
-from . import protocols
-from . import sslproto
-from . import transports
-from .log import logger
-
-
-class _ProactorBasePipeTransport(
-    transports._FlowControlMixin, transports.BaseTransport
-):
-    """Base class for pipe and socket transports."""
-
-    def __init__(self, loop, sock, protocol, waiter=None, extra=None, server=None):
-        super().__init__(extra, loop)
-        self._set_extra(sock)
-        self._sock = sock
-        self.set_protocol(protocol)
-        self._server = server
-        self._buffer = None  # None or bytearray.
-        self._read_fut = None
-        self._write_fut = None
-        self._pending_write = 0
-        self._conn_lost = 0
-        self._closing = False  # Set when close() called.
-        self._eof_written = False
-        if self._server is not None:
-            self._server._attach()
-        self._loop.call_soon(self._protocol.connection_made, self)
-        if waiter is not None:
-            # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled, waiter, None)
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self._sock is None:
-            info.append("closed")
-        elif self._closing:
-            info.append("closing")
-        if self._sock is not None:
-            info.append(f"fd={self._sock.fileno()}")
-        if self._read_fut is not None:
-            info.append(f"read={self._read_fut!r}")
-        if self._write_fut is not None:
-            info.append(f"write={self._write_fut!r}")
-        if self._buffer:
-            info.append(f"write_bufsize={len(self._buffer)}")
-        if self._eof_written:
-            info.append("EOF written")
-        return "<{}>".format(" ".join(info))
-
-    def _set_extra(self, sock):
-        self._extra["pipe"] = sock
-
-    def set_protocol(self, protocol):
-        self._protocol = protocol
-
-    def get_protocol(self):
-        return self._protocol
-
-    def is_closing(self):
-        return self._closing
-
-    def close(self):
-        if self._closing:
-            return
-        self._closing = True
-        self._conn_lost += 1
-        if not self._buffer and self._write_fut is None:
-            self._loop.call_soon(self._call_connection_lost, None)
-        if self._read_fut is not None:
-            self._read_fut.cancel()
-            self._read_fut = None
-
-    def __del__(self):
-        if self._sock is not None:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self.close()
-
-    def _fatal_error(self, exc, message="Fatal error on pipe transport"):
-        try:
-            if isinstance(exc, OSError):
-                if self._loop.get_debug():
-                    logger.debug("%r: %s", self, message, exc_info=True)
-            else:
-                self._loop.call_exception_handler(
-                    {
-                        "message": message,
-                        "exception": exc,
-                        "transport": self,
-                        "protocol": self._protocol,
-                    }
-                )
-        finally:
-            self._force_close(exc)
-
-    def _force_close(self, exc):
-        if self._empty_waiter is not None and not self._empty_waiter.done():
-            if exc is None:
-                self._empty_waiter.set_result(None)
-            else:
-                self._empty_waiter.set_exception(exc)
-        if self._closing:
-            return
-        self._closing = True
-        self._conn_lost += 1
-        if self._write_fut:
-            self._write_fut.cancel()
-            self._write_fut = None
-        if self._read_fut:
-            self._read_fut.cancel()
-            self._read_fut = None
-        self._pending_write = 0
-        self._buffer = None
-        self._loop.call_soon(self._call_connection_lost, exc)
-
-    def _call_connection_lost(self, exc):
-        try:
-            self._protocol.connection_lost(exc)
-        finally:
-            # XXX If there is a pending overlapped read on the other
-            # end then it may fail with ERROR_NETNAME_DELETED if we
-            # just close our end.  First calling shutdown() seems to
-            # cure it, but maybe using DisconnectEx() would be better.
-            if hasattr(self._sock, "shutdown"):
-                self._sock.shutdown(socket.SHUT_RDWR)
-            self._sock.close()
-            self._sock = None
-            server = self._server
-            if server is not None:
-                server._detach()
-                self._server = None
-
-    def get_write_buffer_size(self):
-        size = self._pending_write
-        if self._buffer is not None:
-            size += len(self._buffer)
-        return size
-
-
-class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTransport):
-    """Transport for read pipes."""
-
-    def __init__(self, loop, sock, protocol, waiter=None, extra=None, server=None):
-        self._pending_data = None
-        self._paused = True
-        super().__init__(loop, sock, protocol, waiter, extra, server)
-
-        self._loop.call_soon(self._loop_reading)
-        self._paused = False
-
-    def is_reading(self):
-        return not self._paused and not self._closing
-
-    def pause_reading(self):
-        if self._closing or self._paused:
-            return
-        self._paused = True
-
-        # bpo-33694: Don't cancel self._read_fut because cancelling an
-        # overlapped WSASend() loss silently data with the current proactor
-        # implementation.
-        #
-        # If CancelIoEx() fails with ERROR_NOT_FOUND, it means that WSASend()
-        # completed (even if HasOverlappedIoCompleted() returns 0), but
-        # Overlapped.cancel() currently silently ignores the ERROR_NOT_FOUND
-        # error. Once the overlapped is ignored, the IOCP loop will ignores the
-        # completion I/O event and so not read the result of the overlapped
-        # WSARecv().
-
-        if self._loop.get_debug():
-            logger.debug("%r pauses reading", self)
-
-    def resume_reading(self):
-        if self._closing or not self._paused:
-            return
-
-        self._paused = False
-        if self._read_fut is None:
-            self._loop.call_soon(self._loop_reading, None)
-
-        data = self._pending_data
-        self._pending_data = None
-        if data is not None:
-            # Call the protocol methode after calling _loop_reading(),
-            # since the protocol can decide to pause reading again.
-            self._loop.call_soon(self._data_received, data)
-
-        if self._loop.get_debug():
-            logger.debug("%r resumes reading", self)
-
-    def _eof_received(self):
-        if self._loop.get_debug():
-            logger.debug("%r received EOF", self)
-
-        try:
-            keep_open = self._protocol.eof_received()
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal error: protocol.eof_received() call failed.")
-            return
-
-        if not keep_open:
-            self.close()
-
-    def _data_received(self, data):
-        if self._paused:
-            # Don't call any protocol method while reading is paused.
-            # The protocol will be called on resume_reading().
-            assert self._pending_data is None
-            self._pending_data = data
-            return
-
-        if not data:
-            self._eof_received()
-            return
-
-        if isinstance(self._protocol, protocols.BufferedProtocol):
-            try:
-                protocols._feed_data_to_buffered_proto(self._protocol, data)
-            except Exception as exc:
-                self._fatal_error(
-                    exc, "Fatal error: protocol.buffer_updated() " "call failed."
-                )
-                return
-        else:
-            self._protocol.data_received(data)
-
-    def _loop_reading(self, fut=None):
-        data = None
-        try:
-            if fut is not None:
-                assert self._read_fut is fut or (
-                    self._read_fut is None and self._closing
-                )
-                self._read_fut = None
-                if fut.done():
-                    # deliver data later in "finally" clause
-                    data = fut.result()
-                else:
-                    # the future will be replaced by next proactor.recv call
-                    fut.cancel()
-
-            if self._closing:
-                # since close() has been called we ignore any read data
-                data = None
-                return
-
-            if data == b"":
-                # we got end-of-file so no need to reschedule a new read
-                return
-
-            # bpo-33694: buffer_updated() has currently no fast path because of
-            # a data loss issue caused by overlapped WSASend() cancellation.
-
-            if not self._paused:
-                # reschedule a new read
-                self._read_fut = self._loop._proactor.recv(self._sock, 32768)
-        except ConnectionAbortedError as exc:
-            if not self._closing:
-                self._fatal_error(exc, "Fatal read error on pipe transport")
-            elif self._loop.get_debug():
-                logger.debug(
-                    "Read error on pipe transport while closing", exc_info=True
-                )
-        except ConnectionResetError as exc:
-            self._force_close(exc)
-        except OSError as exc:
-            self._fatal_error(exc, "Fatal read error on pipe transport")
-        except futures.CancelledError:
-            if not self._closing:
-                raise
-        else:
-            if not self._paused:
-                self._read_fut.add_done_callback(self._loop_reading)
-        finally:
-            if data is not None:
-                self._data_received(data)
-
-
-class _ProactorBaseWritePipeTransport(
-    _ProactorBasePipeTransport, transports.WriteTransport
-):
-    """Transport for write pipes."""
-
-    _start_tls_compatible = True
-
-    def __init__(self, *args, **kw):
-        super().__init__(*args, **kw)
-        self._empty_waiter = None
-
-    def write(self, data):
-        if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(
-                f"data argument must be a bytes-like object, "
-                f"not {type(data).__name__}"
-            )
-        if self._eof_written:
-            raise RuntimeError("write_eof() already called")
-        if self._empty_waiter is not None:
-            raise RuntimeError("unable to write; sendfile is in progress")
-
-        if not data:
-            return
-
-        if self._conn_lost:
-            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
-                logger.warning("socket.send() raised exception.")
-            self._conn_lost += 1
-            return
-
-        # Observable states:
-        # 1. IDLE: _write_fut and _buffer both None
-        # 2. WRITING: _write_fut set; _buffer None
-        # 3. BACKED UP: _write_fut set; _buffer a bytearray
-        # We always copy the data, so the caller can't modify it
-        # while we're still waiting for the I/O to happen.
-        if self._write_fut is None:  # IDLE -> WRITING
-            assert self._buffer is None
-            # Pass a copy, except if it's already immutable.
-            self._loop_writing(data=bytes(data))
-        elif not self._buffer:  # WRITING -> BACKED UP
-            # Make a mutable copy which we can extend.
-            self._buffer = bytearray(data)
-            self._maybe_pause_protocol()
-        else:  # BACKED UP
-            # Append to buffer (also copies).
-            self._buffer.extend(data)
-            self._maybe_pause_protocol()
-
-    def _loop_writing(self, f=None, data=None):
-        try:
-            if f is not None and self._write_fut is None and self._closing:
-                # XXX most likely self._force_close() has been called, and
-                # it has set self._write_fut to None.
-                return
-            assert f is self._write_fut
-            self._write_fut = None
-            self._pending_write = 0
-            if f:
-                f.result()
-            if data is None:
-                data = self._buffer
-                self._buffer = None
-            if not data:
-                if self._closing:
-                    self._loop.call_soon(self._call_connection_lost, None)
-                if self._eof_written:
-                    self._sock.shutdown(socket.SHUT_WR)
-                # Now that we've reduced the buffer size, tell the
-                # protocol to resume writing if it was paused.  Note that
-                # we do this last since the callback is called immediately
-                # and it may add more data to the buffer (even causing the
-                # protocol to be paused again).
-                self._maybe_resume_protocol()
-            else:
-                self._write_fut = self._loop._proactor.send(self._sock, data)
-                if not self._write_fut.done():
-                    assert self._pending_write == 0
-                    self._pending_write = len(data)
-                    self._write_fut.add_done_callback(self._loop_writing)
-                    self._maybe_pause_protocol()
-                else:
-                    self._write_fut.add_done_callback(self._loop_writing)
-            if self._empty_waiter is not None and self._write_fut is None:
-                self._empty_waiter.set_result(None)
-        except ConnectionResetError as exc:
-            self._force_close(exc)
-        except OSError as exc:
-            self._fatal_error(exc, "Fatal write error on pipe transport")
-
-    def can_write_eof(self):
-        return True
-
-    def write_eof(self):
-        self.close()
-
-    def abort(self):
-        self._force_close(None)
-
-    def _make_empty_waiter(self):
-        if self._empty_waiter is not None:
-            raise RuntimeError("Empty waiter is already set")
-        self._empty_waiter = self._loop.create_future()
-        if self._write_fut is None:
-            self._empty_waiter.set_result(None)
-        return self._empty_waiter
-
-    def _reset_empty_waiter(self):
-        self._empty_waiter = None
-
-
-class _ProactorWritePipeTransport(_ProactorBaseWritePipeTransport):
-    def __init__(self, *args, **kw):
-        super().__init__(*args, **kw)
-        self._read_fut = self._loop._proactor.recv(self._sock, 16)
-        self._read_fut.add_done_callback(self._pipe_closed)
-
-    def _pipe_closed(self, fut):
-        if fut.cancelled():
-            # the transport has been closed
-            return
-        assert fut.result() == b""
-        if self._closing:
-            assert self._read_fut is None
-            return
-        assert fut is self._read_fut, (fut, self._read_fut)
-        self._read_fut = None
-        if self._write_fut is not None:
-            self._force_close(BrokenPipeError())
-        else:
-            self.close()
-
-
-class _ProactorDuplexPipeTransport(
-    _ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport
-):
-    """Transport for duplex pipes."""
-
-    def can_write_eof(self):
-        return False
-
-    def write_eof(self):
-        raise NotImplementedError
-
-
-class _ProactorSocketTransport(
-    _ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport
-):
-    """Transport for connected sockets."""
-
-    _sendfile_compatible = constants._SendfileMode.TRY_NATIVE
-
-    def __init__(self, loop, sock, protocol, waiter=None, extra=None, server=None):
-        super().__init__(loop, sock, protocol, waiter, extra, server)
-        base_events._set_nodelay(sock)
-
-    def _set_extra(self, sock):
-        self._extra["socket"] = sock
-
-        try:
-            self._extra["sockname"] = sock.getsockname()
-        except (socket.error, AttributeError):
-            if self._loop.get_debug():
-                logger.warning("getsockname() failed on %r", sock, exc_info=True)
-
-        if "peername" not in self._extra:
-            try:
-                self._extra["peername"] = sock.getpeername()
-            except (socket.error, AttributeError):
-                if self._loop.get_debug():
-                    logger.warning("getpeername() failed on %r", sock, exc_info=True)
-
-    def can_write_eof(self):
-        return True
-
-    def write_eof(self):
-        if self._closing or self._eof_written:
-            return
-        self._eof_written = True
-        if self._write_fut is None:
-            self._sock.shutdown(socket.SHUT_WR)
-
-
-class BaseProactorEventLoop(base_events.BaseEventLoop):
-    def __init__(self, proactor):
-        super().__init__()
-        logger.debug("Using proactor: %s", proactor.__class__.__name__)
-        self._proactor = proactor
-        self._selector = proactor  # convenient alias
-        self._self_reading_future = None
-        self._accept_futures = {}  # socket file descriptor => Future
-        proactor.set_loop(self)
-        self._make_self_pipe()
-
-    def _make_socket_transport(
-        self, sock, protocol, waiter=None, extra=None, server=None
-    ):
-        return _ProactorSocketTransport(self, sock, protocol, waiter, extra, server)
-
-    def _make_ssl_transport(
-        self,
-        rawsock,
-        protocol,
-        sslcontext,
-        waiter=None,
-        *,
-        server_side=False,
-        server_hostname=None,
-        extra=None,
-        server=None,
-        ssl_handshake_timeout=None,
-    ):
-        ssl_protocol = sslproto.SSLProtocol(
-            self,
-            protocol,
-            sslcontext,
-            waiter,
-            server_side,
-            server_hostname,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-        )
-        _ProactorSocketTransport(
-            self, rawsock, ssl_protocol, extra=extra, server=server
-        )
-        return ssl_protocol._app_transport
-
-    def _make_duplex_pipe_transport(self, sock, protocol, waiter=None, extra=None):
-        return _ProactorDuplexPipeTransport(self, sock, protocol, waiter, extra)
-
-    def _make_read_pipe_transport(self, sock, protocol, waiter=None, extra=None):
-        return _ProactorReadPipeTransport(self, sock, protocol, waiter, extra)
-
-    def _make_write_pipe_transport(self, sock, protocol, waiter=None, extra=None):
-        # We want connection_lost() to be called when other end closes
-        return _ProactorWritePipeTransport(self, sock, protocol, waiter, extra)
-
-    def close(self):
-        if self.is_running():
-            raise RuntimeError("Cannot close a running event loop")
-        if self.is_closed():
-            return
-
-        # Call these methods before closing the event loop (before calling
-        # BaseEventLoop.close), because they can schedule callbacks with
-        # call_soon(), which is forbidden when the event loop is closed.
-        self._stop_accept_futures()
-        self._close_self_pipe()
-        self._proactor.close()
-        self._proactor = None
-        self._selector = None
-
-        # Close the event loop
-        super().close()
-
-    async def sock_recv(self, sock, n):
-        return await self._proactor.recv(sock, n)
-
-    async def sock_recv_into(self, sock, buf):
-        return await self._proactor.recv_into(sock, buf)
-
-    async def sock_sendall(self, sock, data):
-        return await self._proactor.send(sock, data)
-
-    async def sock_connect(self, sock, address):
-        return await self._proactor.connect(sock, address)
-
-    async def sock_accept(self, sock):
-        return await self._proactor.accept(sock)
-
-    async def _sock_sendfile_native(self, sock, file, offset, count):
-        try:
-            fileno = file.fileno()
-        except (AttributeError, io.UnsupportedOperation) as err:
-            raise events.SendfileNotAvailableError("not a regular file")
-        try:
-            fsize = os.fstat(fileno).st_size
-        except OSError as err:
-            raise events.SendfileNotAvailableError("not a regular file")
-        blocksize = count if count else fsize
-        if not blocksize:
-            return 0  # empty file
-
-        blocksize = min(blocksize, 0xFFFF_FFFF)
-        end_pos = min(offset + count, fsize) if count else fsize
-        offset = min(offset, fsize)
-        total_sent = 0
-        try:
-            while True:
-                blocksize = min(end_pos - offset, blocksize)
-                if blocksize <= 0:
-                    return total_sent
-                await self._proactor.sendfile(sock, file, offset, blocksize)
-                offset += blocksize
-                total_sent += blocksize
-        finally:
-            if total_sent > 0:
-                file.seek(offset)
-
-    async def _sendfile_native(self, transp, file, offset, count):
-        resume_reading = transp.is_reading()
-        transp.pause_reading()
-        await transp._make_empty_waiter()
-        try:
-            return await self.sock_sendfile(
-                transp._sock, file, offset, count, fallback=False
-            )
-        finally:
-            transp._reset_empty_waiter()
-            if resume_reading:
-                transp.resume_reading()
-
-    def _close_self_pipe(self):
-        if self._self_reading_future is not None:
-            self._self_reading_future.cancel()
-            self._self_reading_future = None
-        self._ssock.close()
-        self._ssock = None
-        self._csock.close()
-        self._csock = None
-        self._internal_fds -= 1
-
-    def _make_self_pipe(self):
-        # A self-socket, really. :-)
-        self._ssock, self._csock = socket.socketpair()
-        self._ssock.setblocking(False)
-        self._csock.setblocking(False)
-        self._internal_fds += 1
-        self.call_soon(self._loop_self_reading)
-
-    def _loop_self_reading(self, f=None):
-        try:
-            if f is not None:
-                f.result()  # may raise
-            f = self._proactor.recv(self._ssock, 4096)
-        except futures.CancelledError:
-            # _close_self_pipe() has been called, stop waiting for data
-            return
-        except Exception as exc:
-            self.call_exception_handler(
-                {
-                    "message": "Error on reading from the event loop self pipe",
-                    "exception": exc,
-                    "loop": self,
-                }
-            )
-        else:
-            self._self_reading_future = f
-            f.add_done_callback(self._loop_self_reading)
-
-    def _write_to_self(self):
-        try:
-            self._csock.send(b"\0")
-        except OSError:
-            if self._debug:
-                logger.debug(
-                    "Fail to write a null byte into the " "self-pipe socket",
-                    exc_info=True,
-                )
-
-    def _start_serving(
-        self,
-        protocol_factory,
-        sock,
-        sslcontext=None,
-        server=None,
-        backlog=100,
-        ssl_handshake_timeout=None,
-    ):
-        def loop(f=None):
-            try:
-                if f is not None:
-                    conn, addr = f.result()
-                    if self._debug:
-                        logger.debug(
-                            "%r got a new connection from %r: %r", server, addr, conn
-                        )
-                    protocol = protocol_factory()
-                    if sslcontext is not None:
-                        self._make_ssl_transport(
-                            conn,
-                            protocol,
-                            sslcontext,
-                            server_side=True,
-                            extra={"peername": addr},
-                            server=server,
-                            ssl_handshake_timeout=ssl_handshake_timeout,
-                        )
-                    else:
-                        self._make_socket_transport(
-                            conn, protocol, extra={"peername": addr}, server=server
-                        )
-                if self.is_closed():
-                    return
-                f = self._proactor.accept(sock)
-            except OSError as exc:
-                if sock.fileno() != -1:
-                    self.call_exception_handler(
-                        {
-                            "message": "Accept failed on a socket",
-                            "exception": exc,
-                            "socket": sock,
-                        }
-                    )
-                    sock.close()
-                elif self._debug:
-                    logger.debug("Accept failed on socket %r", sock, exc_info=True)
-            except futures.CancelledError:
-                sock.close()
-            else:
-                self._accept_futures[sock.fileno()] = f
-                f.add_done_callback(loop)
-
-        self.call_soon(loop)
-
-    def _process_events(self, event_list):
-        # Events are processed in the IocpProactor._poll() method
-        pass
-
-    def _stop_accept_futures(self):
-        for future in self._accept_futures.values():
-            future.cancel()
-        self._accept_futures.clear()
-
-    def _stop_serving(self, sock):
-        future = self._accept_futures.pop(sock.fileno(), None)
-        if future:
-            future.cancel()
-        self._proactor._stop_serving(sock)
-        sock.close()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/protocols.py b/addon/globalPlugins/spellcheck/libs/asyncio/protocols.py
deleted file mode 100644
index c2f26c2..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/protocols.py
+++ /dev/null
@@ -1,213 +0,0 @@
-"""Abstract Protocol base classes."""
-
-__all__ = (
-    "BaseProtocol",
-    "Protocol",
-    "DatagramProtocol",
-    "SubprocessProtocol",
-    "BufferedProtocol",
-)
-
-
-class BaseProtocol:
-    """Common base class for protocol interfaces.
-
-    Usually user implements protocols that derived from BaseProtocol
-    like Protocol or ProcessProtocol.
-
-    The only case when BaseProtocol should be implemented directly is
-    write-only transport like write pipe
-    """
-
-    def connection_made(self, transport):
-        """Called when a connection is made.
-
-        The argument is the transport representing the pipe connection.
-        To receive data, wait for data_received() calls.
-        When the connection is closed, connection_lost() is called.
-        """
-
-    def connection_lost(self, exc):
-        """Called when the connection is lost or closed.
-
-        The argument is an exception object or None (the latter
-        meaning a regular EOF is received or the connection was
-        aborted or closed).
-        """
-
-    def pause_writing(self):
-        """Called when the transport's buffer goes over the high-water mark.
-
-        Pause and resume calls are paired -- pause_writing() is called
-        once when the buffer goes strictly over the high-water mark
-        (even if subsequent writes increases the buffer size even
-        more), and eventually resume_writing() is called once when the
-        buffer size reaches the low-water mark.
-
-        Note that if the buffer size equals the high-water mark,
-        pause_writing() is not called -- it must go strictly over.
-        Conversely, resume_writing() is called when the buffer size is
-        equal or lower than the low-water mark.  These end conditions
-        are important to ensure that things go as expected when either
-        mark is zero.
-
-        NOTE: This is the only Protocol callback that is not called
-        through EventLoop.call_soon() -- if it were, it would have no
-        effect when it's most needed (when the app keeps writing
-        without yielding until pause_writing() is called).
-        """
-
-    def resume_writing(self):
-        """Called when the transport's buffer drains below the low-water mark.
-
-        See pause_writing() for details.
-        """
-
-
-class Protocol(BaseProtocol):
-    """Interface for stream protocol.
-
-    The user should implement this interface.  They can inherit from
-    this class but don't need to.  The implementations here do
-    nothing (they don't raise exceptions).
-
-    When the user wants to requests a transport, they pass a protocol
-    factory to a utility function (e.g., EventLoop.create_connection()).
-
-    When the connection is made successfully, connection_made() is
-    called with a suitable transport object.  Then data_received()
-    will be called 0 or more times with data (bytes) received from the
-    transport; finally, connection_lost() will be called exactly once
-    with either an exception object or None as an argument.
-
-    State machine of calls:
-
-      start -> CM [-> DR*] [-> ER?] -> CL -> end
-
-    * CM: connection_made()
-    * DR: data_received()
-    * ER: eof_received()
-    * CL: connection_lost()
-    """
-
-    def data_received(self, data):
-        """Called when some data is received.
-
-        The argument is a bytes object.
-        """
-
-    def eof_received(self):
-        """Called when the other end calls write_eof() or equivalent.
-
-        If this returns a false value (including None), the transport
-        will close itself.  If it returns a true value, closing the
-        transport is up to the protocol.
-        """
-
-
-class BufferedProtocol(BaseProtocol):
-    """Interface for stream protocol with manual buffer control.
-
-    Important: this has been added to asyncio in Python 3.7
-    *on a provisional basis*!  Consider it as an experimental API that
-    might be changed or removed in Python 3.8.
-
-    Event methods, such as `create_server` and `create_connection`,
-    accept factories that return protocols that implement this interface.
-
-    The idea of BufferedProtocol is that it allows to manually allocate
-    and control the receive buffer.  Event loops can then use the buffer
-    provided by the protocol to avoid unnecessary data copies.  This
-    can result in noticeable performance improvement for protocols that
-    receive big amounts of data.  Sophisticated protocols can allocate
-    the buffer only once at creation time.
-
-    State machine of calls:
-
-      start -> CM [-> GB [-> BU?]]* [-> ER?] -> CL -> end
-
-    * CM: connection_made()
-    * GB: get_buffer()
-    * BU: buffer_updated()
-    * ER: eof_received()
-    * CL: connection_lost()
-    """
-
-    def get_buffer(self, sizehint):
-        """Called to allocate a new receive buffer.
-
-        *sizehint* is a recommended minimal size for the returned
-        buffer.  When set to -1, the buffer size can be arbitrary.
-
-        Must return an object that implements the
-        :ref:`buffer protocol <bufferobjects>`.
-        It is an error to return a zero-sized buffer.
-        """
-
-    def buffer_updated(self, nbytes):
-        """Called when the buffer was updated with the received data.
-
-        *nbytes* is the total number of bytes that were written to
-        the buffer.
-        """
-
-    def eof_received(self):
-        """Called when the other end calls write_eof() or equivalent.
-
-        If this returns a false value (including None), the transport
-        will close itself.  If it returns a true value, closing the
-        transport is up to the protocol.
-        """
-
-
-class DatagramProtocol(BaseProtocol):
-    """Interface for datagram protocol."""
-
-    def datagram_received(self, data, addr):
-        """Called when some datagram is received."""
-
-    def error_received(self, exc):
-        """Called when a send or receive operation raises an OSError.
-
-        (Other than BlockingIOError or InterruptedError.)
-        """
-
-
-class SubprocessProtocol(BaseProtocol):
-    """Interface for protocol for subprocess calls."""
-
-    def pipe_data_received(self, fd, data):
-        """Called when the subprocess writes data into stdout/stderr pipe.
-
-        fd is int file descriptor.
-        data is bytes object.
-        """
-
-    def pipe_connection_lost(self, fd, exc):
-        """Called when a file descriptor associated with the child process is
-        closed.
-
-        fd is the int file descriptor that was closed.
-        """
-
-    def process_exited(self):
-        """Called when subprocess has exited."""
-
-
-def _feed_data_to_buffered_proto(proto, data):
-    data_len = len(data)
-    while data_len:
-        buf = proto.get_buffer(data_len)
-        buf_len = len(buf)
-        if not buf_len:
-            raise RuntimeError("get_buffer() returned an empty buffer")
-
-        if buf_len >= data_len:
-            buf[:data_len] = data
-            proto.buffer_updated(data_len)
-            return
-        else:
-            buf[:buf_len] = data[:buf_len]
-            proto.buffer_updated(buf_len)
-            data = data[buf_len:]
-            data_len = len(data)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/queues.py b/addon/globalPlugins/spellcheck/libs/asyncio/queues.py
deleted file mode 100644
index f239916..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/queues.py
+++ /dev/null
@@ -1,247 +0,0 @@
-__all__ = ("Queue", "PriorityQueue", "LifoQueue", "QueueFull", "QueueEmpty")
-
-import collections
-import heapq
-
-from . import events
-from . import locks
-
-
-class QueueEmpty(Exception):
-    """Raised when Queue.get_nowait() is called on an empty Queue."""
-
-    pass
-
-
-class QueueFull(Exception):
-    """Raised when the Queue.put_nowait() method is called on a full Queue."""
-
-    pass
-
-
-class Queue:
-    """A queue, useful for coordinating producer and consumer coroutines.
-
-    If maxsize is less than or equal to zero, the queue size is infinite. If it
-    is an integer greater than 0, then "await put()" will block when the
-    queue reaches maxsize, until an item is removed by get().
-
-    Unlike the standard library Queue, you can reliably know this Queue's size
-    with qsize(), since your single-threaded asyncio application won't be
-    interrupted between calling qsize() and doing an operation on the Queue.
-    """
-
-    def __init__(self, maxsize=0, *, loop=None):
-        if loop is None:
-            self._loop = events.get_event_loop()
-        else:
-            self._loop = loop
-        self._maxsize = maxsize
-
-        # Futures.
-        self._getters = collections.deque()
-        # Futures.
-        self._putters = collections.deque()
-        self._unfinished_tasks = 0
-        self._finished = locks.Event(loop=self._loop)
-        self._finished.set()
-        self._init(maxsize)
-
-    # These three are overridable in subclasses.
-
-    def _init(self, maxsize):
-        self._queue = collections.deque()
-
-    def _get(self):
-        return self._queue.popleft()
-
-    def _put(self, item):
-        self._queue.append(item)
-
-    # End of the overridable methods.
-
-    def _wakeup_next(self, waiters):
-        # Wake up the next waiter (if any) that isn't cancelled.
-        while waiters:
-            waiter = waiters.popleft()
-            if not waiter.done():
-                waiter.set_result(None)
-                break
-
-    def __repr__(self):
-        return f"<{type(self).__name__} at {id(self):#x} {self._format()}>"
-
-    def __str__(self):
-        return f"<{type(self).__name__} {self._format()}>"
-
-    def _format(self):
-        result = f"maxsize={self._maxsize!r}"
-        if getattr(self, "_queue", None):
-            result += f" _queue={list(self._queue)!r}"
-        if self._getters:
-            result += f" _getters[{len(self._getters)}]"
-        if self._putters:
-            result += f" _putters[{len(self._putters)}]"
-        if self._unfinished_tasks:
-            result += f" tasks={self._unfinished_tasks}"
-        return result
-
-    def qsize(self):
-        """Number of items in the queue."""
-        return len(self._queue)
-
-    @property
-    def maxsize(self):
-        """Number of items allowed in the queue."""
-        return self._maxsize
-
-    def empty(self):
-        """Return True if the queue is empty, False otherwise."""
-        return not self._queue
-
-    def full(self):
-        """Return True if there are maxsize items in the queue.
-
-        Note: if the Queue was initialized with maxsize=0 (the default),
-        then full() is never True.
-        """
-        if self._maxsize <= 0:
-            return False
-        else:
-            return self.qsize() >= self._maxsize
-
-    async def put(self, item):
-        """Put an item into the queue.
-
-        Put an item into the queue. If the queue is full, wait until a free
-        slot is available before adding item.
-        """
-        while self.full():
-            putter = self._loop.create_future()
-            self._putters.append(putter)
-            try:
-                await putter
-            except:
-                putter.cancel()  # Just in case putter is not done yet.
-                try:
-                    # Clean self._putters from canceled putters.
-                    self._putters.remove(putter)
-                except ValueError:
-                    # The putter could be removed from self._putters by a
-                    # previous get_nowait call.
-                    pass
-                if not self.full() and not putter.cancelled():
-                    # We were woken up by get_nowait(), but can't take
-                    # the call.  Wake up the next in line.
-                    self._wakeup_next(self._putters)
-                raise
-        return self.put_nowait(item)
-
-    def put_nowait(self, item):
-        """Put an item into the queue without blocking.
-
-        If no free slot is immediately available, raise QueueFull.
-        """
-        if self.full():
-            raise QueueFull
-        self._put(item)
-        self._unfinished_tasks += 1
-        self._finished.clear()
-        self._wakeup_next(self._getters)
-
-    async def get(self):
-        """Remove and return an item from the queue.
-
-        If queue is empty, wait until an item is available.
-        """
-        while self.empty():
-            getter = self._loop.create_future()
-            self._getters.append(getter)
-            try:
-                await getter
-            except:
-                getter.cancel()  # Just in case getter is not done yet.
-                try:
-                    # Clean self._getters from canceled getters.
-                    self._getters.remove(getter)
-                except ValueError:
-                    # The getter could be removed from self._getters by a
-                    # previous put_nowait call.
-                    pass
-                if not self.empty() and not getter.cancelled():
-                    # We were woken up by put_nowait(), but can't take
-                    # the call.  Wake up the next in line.
-                    self._wakeup_next(self._getters)
-                raise
-        return self.get_nowait()
-
-    def get_nowait(self):
-        """Remove and return an item from the queue.
-
-        Return an item if one is immediately available, else raise QueueEmpty.
-        """
-        if self.empty():
-            raise QueueEmpty
-        item = self._get()
-        self._wakeup_next(self._putters)
-        return item
-
-    def task_done(self):
-        """Indicate that a formerly enqueued task is complete.
-
-        Used by queue consumers. For each get() used to fetch a task,
-        a subsequent call to task_done() tells the queue that the processing
-        on the task is complete.
-
-        If a join() is currently blocking, it will resume when all items have
-        been processed (meaning that a task_done() call was received for every
-        item that had been put() into the queue).
-
-        Raises ValueError if called more times than there were items placed in
-        the queue.
-        """
-        if self._unfinished_tasks <= 0:
-            raise ValueError("task_done() called too many times")
-        self._unfinished_tasks -= 1
-        if self._unfinished_tasks == 0:
-            self._finished.set()
-
-    async def join(self):
-        """Block until all items in the queue have been gotten and processed.
-
-        The count of unfinished tasks goes up whenever an item is added to the
-        queue. The count goes down whenever a consumer calls task_done() to
-        indicate that the item was retrieved and all work on it is complete.
-        When the count of unfinished tasks drops to zero, join() unblocks.
-        """
-        if self._unfinished_tasks > 0:
-            await self._finished.wait()
-
-
-class PriorityQueue(Queue):
-    """A subclass of Queue; retrieves entries in priority order (lowest first).
-
-    Entries are typically tuples of the form: (priority number, data).
-    """
-
-    def _init(self, maxsize):
-        self._queue = []
-
-    def _put(self, item, heappush=heapq.heappush):
-        heappush(self._queue, item)
-
-    def _get(self, heappop=heapq.heappop):
-        return heappop(self._queue)
-
-
-class LifoQueue(Queue):
-    """A subclass of Queue that retrieves most recently added entries first."""
-
-    def _init(self, maxsize):
-        self._queue = []
-
-    def _put(self, item):
-        self._queue.append(item)
-
-    def _get(self):
-        return self._queue.pop()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/runners.py b/addon/globalPlugins/spellcheck/libs/asyncio/runners.py
deleted file mode 100644
index b02e3d7..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/runners.py
+++ /dev/null
@@ -1,72 +0,0 @@
-__all__ = ("run",)
-
-from . import coroutines
-from . import events
-from . import tasks
-
-
-def run(main, *, debug=False):
-    """Execute the coroutine and return the result.
-
-    This function runs the passed coroutine, taking care of
-    managing the asyncio event loop and finalizing asynchronous
-    generators.
-
-    This function cannot be called when another asyncio event loop is
-    running in the same thread.
-
-    If debug is True, the event loop will be run in debug mode.
-
-    This function always creates a new event loop and closes it at the end.
-    It should be used as a main entry point for asyncio programs, and should
-    ideally only be called once.
-
-    Example:
-
-        async def main():
-            await asyncio.sleep(1)
-            print('hello')
-
-        asyncio.run(main())
-    """
-    if events._get_running_loop() is not None:
-        raise RuntimeError("asyncio.run() cannot be called from a running event loop")
-
-    if not coroutines.iscoroutine(main):
-        raise ValueError("a coroutine was expected, got {!r}".format(main))
-
-    loop = events.new_event_loop()
-    try:
-        events.set_event_loop(loop)
-        loop.set_debug(debug)
-        return loop.run_until_complete(main)
-    finally:
-        try:
-            _cancel_all_tasks(loop)
-            loop.run_until_complete(loop.shutdown_asyncgens())
-        finally:
-            events.set_event_loop(None)
-            loop.close()
-
-
-def _cancel_all_tasks(loop):
-    to_cancel = tasks.all_tasks(loop)
-    if not to_cancel:
-        return
-
-    for task in to_cancel:
-        task.cancel()
-
-    loop.run_until_complete(tasks.gather(*to_cancel, loop=loop, return_exceptions=True))
-
-    for task in to_cancel:
-        if task.cancelled():
-            continue
-        if task.exception() is not None:
-            loop.call_exception_handler(
-                {
-                    "message": "unhandled exception during asyncio.run() shutdown",
-                    "exception": task.exception(),
-                    "task": task,
-                }
-            )
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/selector_events.py b/addon/globalPlugins/spellcheck/libs/asyncio/selector_events.py
deleted file mode 100644
index 066ce88..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/selector_events.py
+++ /dev/null
@@ -1,1095 +0,0 @@
-"""Event loop using a selector and related classes.
-
-A selector is a "notify-when-ready" multiplexer.  For a subclass which
-also includes support for signal handling, see the unix_events sub-module.
-"""
-
-__all__ = ("BaseSelectorEventLoop",)
-
-import collections
-import errno
-import functools
-import selectors
-import socket
-import warnings
-import weakref
-
-try:
-    import ssl
-except ImportError:  # pragma: no cover
-    ssl = None
-
-from . import base_events
-from . import constants
-from . import events
-from . import futures
-from . import protocols
-from . import sslproto
-from . import transports
-from .log import logger
-
-
-def _test_selector_event(selector, fd, event):
-    # Test if the selector is monitoring 'event' events
-    # for the file descriptor 'fd'.
-    try:
-        key = selector.get_key(fd)
-    except KeyError:
-        return False
-    else:
-        return bool(key.events & event)
-
-
-def _check_ssl_socket(sock):
-    if ssl is not None and isinstance(sock, ssl.SSLSocket):
-        raise TypeError("Socket cannot be of type SSLSocket")
-
-
-class BaseSelectorEventLoop(base_events.BaseEventLoop):
-    """Selector event loop.
-
-    See events.EventLoop for API specification.
-    """
-
-    def __init__(self, selector=None):
-        super().__init__()
-
-        if selector is None:
-            selector = selectors.DefaultSelector()
-        logger.debug("Using selector: %s", selector.__class__.__name__)
-        self._selector = selector
-        self._make_self_pipe()
-        self._transports = weakref.WeakValueDictionary()
-
-    def _make_socket_transport(
-        self, sock, protocol, waiter=None, *, extra=None, server=None
-    ):
-        return _SelectorSocketTransport(self, sock, protocol, waiter, extra, server)
-
-    def _make_ssl_transport(
-        self,
-        rawsock,
-        protocol,
-        sslcontext,
-        waiter=None,
-        *,
-        server_side=False,
-        server_hostname=None,
-        extra=None,
-        server=None,
-        ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
-    ):
-        ssl_protocol = sslproto.SSLProtocol(
-            self,
-            protocol,
-            sslcontext,
-            waiter,
-            server_side,
-            server_hostname,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-        )
-        _SelectorSocketTransport(
-            self, rawsock, ssl_protocol, extra=extra, server=server
-        )
-        return ssl_protocol._app_transport
-
-    def _make_datagram_transport(
-        self, sock, protocol, address=None, waiter=None, extra=None
-    ):
-        return _SelectorDatagramTransport(self, sock, protocol, address, waiter, extra)
-
-    def close(self):
-        if self.is_running():
-            raise RuntimeError("Cannot close a running event loop")
-        if self.is_closed():
-            return
-        self._close_self_pipe()
-        super().close()
-        if self._selector is not None:
-            self._selector.close()
-            self._selector = None
-
-    def _close_self_pipe(self):
-        self._remove_reader(self._ssock.fileno())
-        self._ssock.close()
-        self._ssock = None
-        self._csock.close()
-        self._csock = None
-        self._internal_fds -= 1
-
-    def _make_self_pipe(self):
-        # A self-socket, really. :-)
-        self._ssock, self._csock = socket.socketpair()
-        self._ssock.setblocking(False)
-        self._csock.setblocking(False)
-        self._internal_fds += 1
-        self._add_reader(self._ssock.fileno(), self._read_from_self)
-
-    def _process_self_data(self, data):
-        pass
-
-    def _read_from_self(self):
-        while True:
-            try:
-                data = self._ssock.recv(4096)
-                if not data:
-                    break
-                self._process_self_data(data)
-            except InterruptedError:
-                continue
-            except BlockingIOError:
-                break
-
-    def _write_to_self(self):
-        # This may be called from a different thread, possibly after
-        # _close_self_pipe() has been called or even while it is
-        # running.  Guard for self._csock being None or closed.  When
-        # a socket is closed, send() raises OSError (with errno set to
-        # EBADF, but let's not rely on the exact error code).
-        csock = self._csock
-        if csock is not None:
-            try:
-                csock.send(b"\0")
-            except OSError:
-                if self._debug:
-                    logger.debug(
-                        "Fail to write a null byte into the " "self-pipe socket",
-                        exc_info=True,
-                    )
-
-    def _start_serving(
-        self,
-        protocol_factory,
-        sock,
-        sslcontext=None,
-        server=None,
-        backlog=100,
-        ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
-    ):
-        self._add_reader(
-            sock.fileno(),
-            self._accept_connection,
-            protocol_factory,
-            sock,
-            sslcontext,
-            server,
-            backlog,
-            ssl_handshake_timeout,
-        )
-
-    def _accept_connection(
-        self,
-        protocol_factory,
-        sock,
-        sslcontext=None,
-        server=None,
-        backlog=100,
-        ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
-    ):
-        # This method is only called once for each event loop tick where the
-        # listening socket has triggered an EVENT_READ. There may be multiple
-        # connections waiting for an .accept() so it is called in a loop.
-        # See https://bugs.python.org/issue27906 for more details.
-        for _ in range(backlog):
-            try:
-                conn, addr = sock.accept()
-                if self._debug:
-                    logger.debug(
-                        "%r got a new connection from %r: %r", server, addr, conn
-                    )
-                conn.setblocking(False)
-            except (BlockingIOError, InterruptedError, ConnectionAbortedError):
-                # Early exit because the socket accept buffer is empty.
-                return None
-            except OSError as exc:
-                # There's nowhere to send the error, so just log it.
-                if exc.errno in (
-                    errno.EMFILE,
-                    errno.ENFILE,
-                    errno.ENOBUFS,
-                    errno.ENOMEM,
-                ):
-                    # Some platforms (e.g. Linux keep reporting the FD as
-                    # ready, so we remove the read handler temporarily.
-                    # We'll try again in a while.
-                    self.call_exception_handler(
-                        {
-                            "message": "socket.accept() out of system resource",
-                            "exception": exc,
-                            "socket": sock,
-                        }
-                    )
-                    self._remove_reader(sock.fileno())
-                    self.call_later(
-                        constants.ACCEPT_RETRY_DELAY,
-                        self._start_serving,
-                        protocol_factory,
-                        sock,
-                        sslcontext,
-                        server,
-                        backlog,
-                        ssl_handshake_timeout,
-                    )
-                else:
-                    raise  # The event loop will catch, log and ignore it.
-            else:
-                extra = {"peername": addr}
-                accept = self._accept_connection2(
-                    protocol_factory,
-                    conn,
-                    extra,
-                    sslcontext,
-                    server,
-                    ssl_handshake_timeout,
-                )
-                self.create_task(accept)
-
-    async def _accept_connection2(
-        self,
-        protocol_factory,
-        conn,
-        extra,
-        sslcontext=None,
-        server=None,
-        ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
-    ):
-        protocol = None
-        transport = None
-        try:
-            protocol = protocol_factory()
-            waiter = self.create_future()
-            if sslcontext:
-                transport = self._make_ssl_transport(
-                    conn,
-                    protocol,
-                    sslcontext,
-                    waiter=waiter,
-                    server_side=True,
-                    extra=extra,
-                    server=server,
-                    ssl_handshake_timeout=ssl_handshake_timeout,
-                )
-            else:
-                transport = self._make_socket_transport(
-                    conn, protocol, waiter=waiter, extra=extra, server=server
-                )
-
-            try:
-                await waiter
-            except:
-                transport.close()
-                raise
-
-            # It's now up to the protocol to handle the connection.
-        except Exception as exc:
-            if self._debug:
-                context = {
-                    "message": "Error on transport creation for incoming connection",
-                    "exception": exc,
-                }
-                if protocol is not None:
-                    context["protocol"] = protocol
-                if transport is not None:
-                    context["transport"] = transport
-                self.call_exception_handler(context)
-
-    def _ensure_fd_no_transport(self, fd):
-        fileno = fd
-        if not isinstance(fileno, int):
-            try:
-                fileno = int(fileno.fileno())
-            except (AttributeError, TypeError, ValueError):
-                # This code matches selectors._fileobj_to_fd function.
-                raise ValueError(f"Invalid file object: {fd!r}") from None
-        try:
-            transport = self._transports[fileno]
-        except KeyError:
-            pass
-        else:
-            if not transport.is_closing():
-                raise RuntimeError(
-                    f"File descriptor {fd!r} is used by transport " f"{transport!r}"
-                )
-
-    def _add_reader(self, fd, callback, *args):
-        self._check_closed()
-        handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, selectors.EVENT_READ, (handle, None))
-        else:
-            mask, (reader, writer) = key.events, key.data
-            self._selector.modify(fd, mask | selectors.EVENT_READ, (handle, writer))
-            if reader is not None:
-                reader.cancel()
-
-    def _remove_reader(self, fd):
-        if self.is_closed():
-            return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-        else:
-            mask, (reader, writer) = key.events, key.data
-            mask &= ~selectors.EVENT_READ
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (None, writer))
-
-            if reader is not None:
-                reader.cancel()
-                return True
-            else:
-                return False
-
-    def _add_writer(self, fd, callback, *args):
-        self._check_closed()
-        handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            self._selector.register(fd, selectors.EVENT_WRITE, (None, handle))
-        else:
-            mask, (reader, writer) = key.events, key.data
-            self._selector.modify(fd, mask | selectors.EVENT_WRITE, (reader, handle))
-            if writer is not None:
-                writer.cancel()
-
-    def _remove_writer(self, fd):
-        """Remove a writer callback."""
-        if self.is_closed():
-            return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
-            return False
-        else:
-            mask, (reader, writer) = key.events, key.data
-            # Remove both writer and connector.
-            mask &= ~selectors.EVENT_WRITE
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (reader, None))
-
-            if writer is not None:
-                writer.cancel()
-                return True
-            else:
-                return False
-
-    def add_reader(self, fd, callback, *args):
-        """Add a reader callback."""
-        self._ensure_fd_no_transport(fd)
-        return self._add_reader(fd, callback, *args)
-
-    def remove_reader(self, fd):
-        """Remove a reader callback."""
-        self._ensure_fd_no_transport(fd)
-        return self._remove_reader(fd)
-
-    def add_writer(self, fd, callback, *args):
-        """Add a writer callback.."""
-        self._ensure_fd_no_transport(fd)
-        return self._add_writer(fd, callback, *args)
-
-    def remove_writer(self, fd):
-        """Remove a writer callback."""
-        self._ensure_fd_no_transport(fd)
-        return self._remove_writer(fd)
-
-    async def sock_recv(self, sock, n):
-        """Receive data from the socket.
-
-        The return value is a bytes object representing the data received.
-        The maximum amount of data to be received at once is specified by
-        nbytes.
-        """
-        _check_ssl_socket(sock)
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-        fut = self.create_future()
-        self._sock_recv(fut, None, sock, n)
-        return await fut
-
-    def _sock_recv(self, fut, registered_fd, sock, n):
-        # _sock_recv() can add itself as an I/O callback if the operation can't
-        # be done immediately. Don't use it directly, call sock_recv().
-        if registered_fd is not None:
-            # Remove the callback early.  It should be rare that the
-            # selector says the fd is ready but the call still returns
-            # EAGAIN, and I am willing to take a hit in that case in
-            # order to simplify the common case.
-            self.remove_reader(registered_fd)
-        if fut.cancelled():
-            return
-        try:
-            data = sock.recv(n)
-        except (BlockingIOError, InterruptedError):
-            fd = sock.fileno()
-            self.add_reader(fd, self._sock_recv, fut, fd, sock, n)
-        except Exception as exc:
-            fut.set_exception(exc)
-        else:
-            fut.set_result(data)
-
-    async def sock_recv_into(self, sock, buf):
-        """Receive data from the socket.
-
-        The received data is written into *buf* (a writable buffer).
-        The return value is the number of bytes written.
-        """
-        _check_ssl_socket(sock)
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-        fut = self.create_future()
-        self._sock_recv_into(fut, None, sock, buf)
-        return await fut
-
-    def _sock_recv_into(self, fut, registered_fd, sock, buf):
-        # _sock_recv_into() can add itself as an I/O callback if the operation
-        # can't be done immediately. Don't use it directly, call
-        # sock_recv_into().
-        if registered_fd is not None:
-            # Remove the callback early.  It should be rare that the
-            # selector says the FD is ready but the call still returns
-            # EAGAIN, and I am willing to take a hit in that case in
-            # order to simplify the common case.
-            self.remove_reader(registered_fd)
-        if fut.cancelled():
-            return
-        try:
-            nbytes = sock.recv_into(buf)
-        except (BlockingIOError, InterruptedError):
-            fd = sock.fileno()
-            self.add_reader(fd, self._sock_recv_into, fut, fd, sock, buf)
-        except Exception as exc:
-            fut.set_exception(exc)
-        else:
-            fut.set_result(nbytes)
-
-    async def sock_sendall(self, sock, data):
-        """Send data to the socket.
-
-        The socket must be connected to a remote socket. This method continues
-        to send data from data until either all data has been sent or an
-        error occurs. None is returned on success. On error, an exception is
-        raised, and there is no way to determine how much data, if any, was
-        successfully processed by the receiving end of the connection.
-        """
-        _check_ssl_socket(sock)
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-        fut = self.create_future()
-        if data:
-            self._sock_sendall(fut, None, sock, data)
-        else:
-            fut.set_result(None)
-        return await fut
-
-    def _sock_sendall(self, fut, registered_fd, sock, data):
-        if registered_fd is not None:
-            self.remove_writer(registered_fd)
-        if fut.cancelled():
-            return
-
-        try:
-            n = sock.send(data)
-        except (BlockingIOError, InterruptedError):
-            n = 0
-        except Exception as exc:
-            fut.set_exception(exc)
-            return
-
-        if n == len(data):
-            fut.set_result(None)
-        else:
-            if n:
-                data = data[n:]
-            fd = sock.fileno()
-            self.add_writer(fd, self._sock_sendall, fut, fd, sock, data)
-
-    async def sock_connect(self, sock, address):
-        """Connect to a remote socket at address.
-
-        This method is a coroutine.
-        """
-        _check_ssl_socket(sock)
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-
-        if not hasattr(socket, "AF_UNIX") or sock.family != socket.AF_UNIX:
-            resolved = await self._ensure_resolved(
-                address, family=sock.family, proto=sock.proto, loop=self
-            )
-            _, _, _, _, address = resolved[0]
-
-        fut = self.create_future()
-        self._sock_connect(fut, sock, address)
-        return await fut
-
-    def _sock_connect(self, fut, sock, address):
-        fd = sock.fileno()
-        try:
-            sock.connect(address)
-        except (BlockingIOError, InterruptedError):
-            # Issue #23618: When the C function connect() fails with EINTR, the
-            # connection runs in background. We have to wait until the socket
-            # becomes writable to be notified when the connection succeed or
-            # fails.
-            fut.add_done_callback(functools.partial(self._sock_connect_done, fd))
-            self.add_writer(fd, self._sock_connect_cb, fut, sock, address)
-        except Exception as exc:
-            fut.set_exception(exc)
-        else:
-            fut.set_result(None)
-
-    def _sock_connect_done(self, fd, fut):
-        self.remove_writer(fd)
-
-    def _sock_connect_cb(self, fut, sock, address):
-        if fut.cancelled():
-            return
-
-        try:
-            err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
-            if err != 0:
-                # Jump to any except clause below.
-                raise OSError(err, f"Connect call failed {address}")
-        except (BlockingIOError, InterruptedError):
-            # socket is still registered, the callback will be retried later
-            pass
-        except Exception as exc:
-            fut.set_exception(exc)
-        else:
-            fut.set_result(None)
-
-    async def sock_accept(self, sock):
-        """Accept a connection.
-
-        The socket must be bound to an address and listening for connections.
-        The return value is a pair (conn, address) where conn is a new socket
-        object usable to send and receive data on the connection, and address
-        is the address bound to the socket on the other end of the connection.
-        """
-        _check_ssl_socket(sock)
-        if self._debug and sock.gettimeout() != 0:
-            raise ValueError("the socket must be non-blocking")
-        fut = self.create_future()
-        self._sock_accept(fut, False, sock)
-        return await fut
-
-    def _sock_accept(self, fut, registered, sock):
-        fd = sock.fileno()
-        if registered:
-            self.remove_reader(fd)
-        if fut.cancelled():
-            return
-        try:
-            conn, address = sock.accept()
-            conn.setblocking(False)
-        except (BlockingIOError, InterruptedError):
-            self.add_reader(fd, self._sock_accept, fut, True, sock)
-        except Exception as exc:
-            fut.set_exception(exc)
-        else:
-            fut.set_result((conn, address))
-
-    async def _sendfile_native(self, transp, file, offset, count):
-        del self._transports[transp._sock_fd]
-        resume_reading = transp.is_reading()
-        transp.pause_reading()
-        await transp._make_empty_waiter()
-        try:
-            return await self.sock_sendfile(
-                transp._sock, file, offset, count, fallback=False
-            )
-        finally:
-            transp._reset_empty_waiter()
-            if resume_reading:
-                transp.resume_reading()
-            self._transports[transp._sock_fd] = transp
-
-    def _process_events(self, event_list):
-        for key, mask in event_list:
-            fileobj, (reader, writer) = key.fileobj, key.data
-            if mask & selectors.EVENT_READ and reader is not None:
-                if reader._cancelled:
-                    self._remove_reader(fileobj)
-                else:
-                    self._add_callback(reader)
-            if mask & selectors.EVENT_WRITE and writer is not None:
-                if writer._cancelled:
-                    self._remove_writer(fileobj)
-                else:
-                    self._add_callback(writer)
-
-    def _stop_serving(self, sock):
-        self._remove_reader(sock.fileno())
-        sock.close()
-
-
-class _SelectorTransport(transports._FlowControlMixin, transports.Transport):
-
-    max_size = 256 * 1024  # Buffer size passed to recv().
-
-    _buffer_factory = bytearray  # Constructs initial value for self._buffer.
-
-    # Attribute used in the destructor: it must be set even if the constructor
-    # is not called (see _SelectorSslTransport which may start by raising an
-    # exception)
-    _sock = None
-
-    def __init__(self, loop, sock, protocol, extra=None, server=None):
-        super().__init__(extra, loop)
-        self._extra["socket"] = sock
-        try:
-            self._extra["sockname"] = sock.getsockname()
-        except OSError:
-            self._extra["sockname"] = None
-        if "peername" not in self._extra:
-            try:
-                self._extra["peername"] = sock.getpeername()
-            except socket.error:
-                self._extra["peername"] = None
-        self._sock = sock
-        self._sock_fd = sock.fileno()
-
-        self._protocol_connected = False
-        self.set_protocol(protocol)
-
-        self._server = server
-        self._buffer = self._buffer_factory()
-        self._conn_lost = 0  # Set when call to connection_lost scheduled.
-        self._closing = False  # Set when close() called.
-        if self._server is not None:
-            self._server._attach()
-        loop._transports[self._sock_fd] = self
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self._sock is None:
-            info.append("closed")
-        elif self._closing:
-            info.append("closing")
-        info.append(f"fd={self._sock_fd}")
-        # test if the transport was closed
-        if self._loop is not None and not self._loop.is_closed():
-            polling = _test_selector_event(
-                self._loop._selector, self._sock_fd, selectors.EVENT_READ
-            )
-            if polling:
-                info.append("read=polling")
-            else:
-                info.append("read=idle")
-
-            polling = _test_selector_event(
-                self._loop._selector, self._sock_fd, selectors.EVENT_WRITE
-            )
-            if polling:
-                state = "polling"
-            else:
-                state = "idle"
-
-            bufsize = self.get_write_buffer_size()
-            info.append(f"write=<{state}, bufsize={bufsize}>")
-        return "<{}>".format(" ".join(info))
-
-    def abort(self):
-        self._force_close(None)
-
-    def set_protocol(self, protocol):
-        self._protocol = protocol
-        self._protocol_connected = True
-
-    def get_protocol(self):
-        return self._protocol
-
-    def is_closing(self):
-        return self._closing
-
-    def close(self):
-        if self._closing:
-            return
-        self._closing = True
-        self._loop._remove_reader(self._sock_fd)
-        if not self._buffer:
-            self._conn_lost += 1
-            self._loop._remove_writer(self._sock_fd)
-            self._loop.call_soon(self._call_connection_lost, None)
-
-    def __del__(self):
-        if self._sock is not None:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self._sock.close()
-
-    def _fatal_error(self, exc, message="Fatal error on transport"):
-        # Should be called from exception handler only.
-        if isinstance(exc, OSError):
-            if self._loop.get_debug():
-                logger.debug("%r: %s", self, message, exc_info=True)
-        else:
-            self._loop.call_exception_handler(
-                {
-                    "message": message,
-                    "exception": exc,
-                    "transport": self,
-                    "protocol": self._protocol,
-                }
-            )
-        self._force_close(exc)
-
-    def _force_close(self, exc):
-        if self._conn_lost:
-            return
-        if self._buffer:
-            self._buffer.clear()
-            self._loop._remove_writer(self._sock_fd)
-        if not self._closing:
-            self._closing = True
-            self._loop._remove_reader(self._sock_fd)
-        self._conn_lost += 1
-        self._loop.call_soon(self._call_connection_lost, exc)
-
-    def _call_connection_lost(self, exc):
-        try:
-            if self._protocol_connected:
-                self._protocol.connection_lost(exc)
-        finally:
-            self._sock.close()
-            self._sock = None
-            self._protocol = None
-            self._loop = None
-            server = self._server
-            if server is not None:
-                server._detach()
-                self._server = None
-
-    def get_write_buffer_size(self):
-        return len(self._buffer)
-
-    def _add_reader(self, fd, callback, *args):
-        if self._closing:
-            return
-
-        self._loop._add_reader(fd, callback, *args)
-
-
-class _SelectorSocketTransport(_SelectorTransport):
-
-    _start_tls_compatible = True
-    _sendfile_compatible = constants._SendfileMode.TRY_NATIVE
-
-    def __init__(self, loop, sock, protocol, waiter=None, extra=None, server=None):
-
-        self._read_ready_cb = None
-        super().__init__(loop, sock, protocol, extra, server)
-        self._eof = False
-        self._paused = False
-        self._empty_waiter = None
-
-        # Disable the Nagle algorithm -- small writes will be
-        # sent without waiting for the TCP ACK.  This generally
-        # decreases the latency (in some cases significantly.)
-        base_events._set_nodelay(self._sock)
-
-        self._loop.call_soon(self._protocol.connection_made, self)
-        # only start reading when connection_made() has been called
-        self._loop.call_soon(self._add_reader, self._sock_fd, self._read_ready)
-        if waiter is not None:
-            # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled, waiter, None)
-
-    def set_protocol(self, protocol):
-        if isinstance(protocol, protocols.BufferedProtocol):
-            self._read_ready_cb = self._read_ready__get_buffer
-        else:
-            self._read_ready_cb = self._read_ready__data_received
-
-        super().set_protocol(protocol)
-
-    def is_reading(self):
-        return not self._paused and not self._closing
-
-    def pause_reading(self):
-        if self._closing or self._paused:
-            return
-        self._paused = True
-        self._loop._remove_reader(self._sock_fd)
-        if self._loop.get_debug():
-            logger.debug("%r pauses reading", self)
-
-    def resume_reading(self):
-        if self._closing or not self._paused:
-            return
-        self._paused = False
-        self._add_reader(self._sock_fd, self._read_ready)
-        if self._loop.get_debug():
-            logger.debug("%r resumes reading", self)
-
-    def _read_ready(self):
-        self._read_ready_cb()
-
-    def _read_ready__get_buffer(self):
-        if self._conn_lost:
-            return
-
-        try:
-            buf = self._protocol.get_buffer(-1)
-            if not len(buf):
-                raise RuntimeError("get_buffer() returned an empty buffer")
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal error: protocol.get_buffer() call failed.")
-            return
-
-        try:
-            nbytes = self._sock.recv_into(buf)
-        except (BlockingIOError, InterruptedError):
-            return
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal read error on socket transport")
-            return
-
-        if not nbytes:
-            self._read_ready__on_eof()
-            return
-
-        try:
-            self._protocol.buffer_updated(nbytes)
-        except Exception as exc:
-            self._fatal_error(
-                exc, "Fatal error: protocol.buffer_updated() call failed."
-            )
-
-    def _read_ready__data_received(self):
-        if self._conn_lost:
-            return
-        try:
-            data = self._sock.recv(self.max_size)
-        except (BlockingIOError, InterruptedError):
-            return
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal read error on socket transport")
-            return
-
-        if not data:
-            self._read_ready__on_eof()
-            return
-
-        try:
-            self._protocol.data_received(data)
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal error: protocol.data_received() call failed.")
-
-    def _read_ready__on_eof(self):
-        if self._loop.get_debug():
-            logger.debug("%r received EOF", self)
-
-        try:
-            keep_open = self._protocol.eof_received()
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal error: protocol.eof_received() call failed.")
-            return
-
-        if keep_open:
-            # We're keeping the connection open so the
-            # protocol can write more, but we still can't
-            # receive more, so remove the reader callback.
-            self._loop._remove_reader(self._sock_fd)
-        else:
-            self.close()
-
-    def write(self, data):
-        if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(
-                f"data argument must be a bytes-like object, "
-                f"not {type(data).__name__!r}"
-            )
-        if self._eof:
-            raise RuntimeError("Cannot call write() after write_eof()")
-        if self._empty_waiter is not None:
-            raise RuntimeError("unable to write; sendfile is in progress")
-        if not data:
-            return
-
-        if self._conn_lost:
-            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
-                logger.warning("socket.send() raised exception.")
-            self._conn_lost += 1
-            return
-
-        if not self._buffer:
-            # Optimization: try to send now.
-            try:
-                n = self._sock.send(data)
-            except (BlockingIOError, InterruptedError):
-                pass
-            except Exception as exc:
-                self._fatal_error(exc, "Fatal write error on socket transport")
-                return
-            else:
-                data = data[n:]
-                if not data:
-                    return
-            # Not all was written; register write handler.
-            self._loop._add_writer(self._sock_fd, self._write_ready)
-
-        # Add it to the buffer.
-        self._buffer.extend(data)
-        self._maybe_pause_protocol()
-
-    def _write_ready(self):
-        assert self._buffer, "Data should not be empty"
-
-        if self._conn_lost:
-            return
-        try:
-            n = self._sock.send(self._buffer)
-        except (BlockingIOError, InterruptedError):
-            pass
-        except Exception as exc:
-            self._loop._remove_writer(self._sock_fd)
-            self._buffer.clear()
-            self._fatal_error(exc, "Fatal write error on socket transport")
-            if self._empty_waiter is not None:
-                self._empty_waiter.set_exception(exc)
-        else:
-            if n:
-                del self._buffer[:n]
-            self._maybe_resume_protocol()  # May append to buffer.
-            if not self._buffer:
-                self._loop._remove_writer(self._sock_fd)
-                if self._empty_waiter is not None:
-                    self._empty_waiter.set_result(None)
-                if self._closing:
-                    self._call_connection_lost(None)
-                elif self._eof:
-                    self._sock.shutdown(socket.SHUT_WR)
-
-    def write_eof(self):
-        if self._closing or self._eof:
-            return
-        self._eof = True
-        if not self._buffer:
-            self._sock.shutdown(socket.SHUT_WR)
-
-    def can_write_eof(self):
-        return True
-
-    def _call_connection_lost(self, exc):
-        super()._call_connection_lost(exc)
-        if self._empty_waiter is not None:
-            self._empty_waiter.set_exception(
-                ConnectionError("Connection is closed by peer")
-            )
-
-    def _make_empty_waiter(self):
-        if self._empty_waiter is not None:
-            raise RuntimeError("Empty waiter is already set")
-        self._empty_waiter = self._loop.create_future()
-        if not self._buffer:
-            self._empty_waiter.set_result(None)
-        return self._empty_waiter
-
-    def _reset_empty_waiter(self):
-        self._empty_waiter = None
-
-
-class _SelectorDatagramTransport(_SelectorTransport):
-
-    _buffer_factory = collections.deque
-
-    def __init__(self, loop, sock, protocol, address=None, waiter=None, extra=None):
-        super().__init__(loop, sock, protocol, extra)
-        self._address = address
-        self._loop.call_soon(self._protocol.connection_made, self)
-        # only start reading when connection_made() has been called
-        self._loop.call_soon(self._add_reader, self._sock_fd, self._read_ready)
-        if waiter is not None:
-            # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled, waiter, None)
-
-    def get_write_buffer_size(self):
-        return sum(len(data) for data, _ in self._buffer)
-
-    def _read_ready(self):
-        if self._conn_lost:
-            return
-        try:
-            data, addr = self._sock.recvfrom(self.max_size)
-        except (BlockingIOError, InterruptedError):
-            pass
-        except OSError as exc:
-            self._protocol.error_received(exc)
-        except Exception as exc:
-            self._fatal_error(exc, "Fatal read error on datagram transport")
-        else:
-            self._protocol.datagram_received(data, addr)
-
-    def sendto(self, data, addr=None):
-        if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(
-                f"data argument must be a bytes-like object, "
-                f"not {type(data).__name__!r}"
-            )
-        if not data:
-            return
-
-        if self._address:
-            if addr not in (None, self._address):
-                raise ValueError(f"Invalid address: must be None or {self._address}")
-            addr = self._address
-
-        if self._conn_lost and self._address:
-            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
-                logger.warning("socket.send() raised exception.")
-            self._conn_lost += 1
-            return
-
-        if not self._buffer:
-            # Attempt to send it right away first.
-            try:
-                if self._extra["peername"]:
-                    self._sock.send(data)
-                else:
-                    self._sock.sendto(data, addr)
-                return
-            except (BlockingIOError, InterruptedError):
-                self._loop._add_writer(self._sock_fd, self._sendto_ready)
-            except OSError as exc:
-                self._protocol.error_received(exc)
-                return
-            except Exception as exc:
-                self._fatal_error(exc, "Fatal write error on datagram transport")
-                return
-
-        # Ensure that what we buffer is immutable.
-        self._buffer.append((bytes(data), addr))
-        self._maybe_pause_protocol()
-
-    def _sendto_ready(self):
-        while self._buffer:
-            data, addr = self._buffer.popleft()
-            try:
-                if self._extra["peername"]:
-                    self._sock.send(data)
-                else:
-                    self._sock.sendto(data, addr)
-            except (BlockingIOError, InterruptedError):
-                self._buffer.appendleft((data, addr))  # Try again later.
-                break
-            except OSError as exc:
-                self._protocol.error_received(exc)
-                return
-            except Exception as exc:
-                self._fatal_error(exc, "Fatal write error on datagram transport")
-                return
-
-        self._maybe_resume_protocol()  # May append to buffer.
-        if not self._buffer:
-            self._loop._remove_writer(self._sock_fd)
-            if self._closing:
-                self._call_connection_lost(None)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/sslproto.py b/addon/globalPlugins/spellcheck/libs/asyncio/sslproto.py
deleted file mode 100644
index 946198d..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/sslproto.py
+++ /dev/null
@@ -1,747 +0,0 @@
-import collections
-import warnings
-
-try:
-    import ssl
-except ImportError:  # pragma: no cover
-    ssl = None
-
-from . import base_events
-from . import constants
-from . import protocols
-from . import transports
-from .log import logger
-
-
-def _create_transport_context(server_side, server_hostname):
-    if server_side:
-        raise ValueError("Server side SSL needs a valid SSLContext")
-
-    # Client side may pass ssl=True to use a default
-    # context; in that case the sslcontext passed is None.
-    # The default is secure for client connections.
-    # Python 3.4+: use up-to-date strong settings.
-    sslcontext = ssl.create_default_context()
-    if not server_hostname:
-        sslcontext.check_hostname = False
-    return sslcontext
-
-
-# States of an _SSLPipe.
-_UNWRAPPED = "UNWRAPPED"
-_DO_HANDSHAKE = "DO_HANDSHAKE"
-_WRAPPED = "WRAPPED"
-_SHUTDOWN = "SHUTDOWN"
-
-
-class _SSLPipe(object):
-    """An SSL "Pipe".
-
-    An SSL pipe allows you to communicate with an SSL/TLS protocol instance
-    through memory buffers. It can be used to implement a security layer for an
-    existing connection where you don't have access to the connection's file
-    descriptor, or for some reason you don't want to use it.
-
-    An SSL pipe can be in "wrapped" and "unwrapped" mode. In unwrapped mode,
-    data is passed through untransformed. In wrapped mode, application level
-    data is encrypted to SSL record level data and vice versa. The SSL record
-    level is the lowest level in the SSL protocol suite and is what travels
-    as-is over the wire.
-
-    An SslPipe initially is in "unwrapped" mode. To start SSL, call
-    do_handshake(). To shutdown SSL again, call unwrap().
-    """
-
-    max_size = 256 * 1024  # Buffer size passed to read()
-
-    def __init__(self, context, server_side, server_hostname=None):
-        """
-        The *context* argument specifies the ssl.SSLContext to use.
-
-        The *server_side* argument indicates whether this is a server side or
-        client side transport.
-
-        The optional *server_hostname* argument can be used to specify the
-        hostname you are connecting to. You may only specify this parameter if
-        the _ssl module supports Server Name Indication (SNI).
-        """
-        self._context = context
-        self._server_side = server_side
-        self._server_hostname = server_hostname
-        self._state = _UNWRAPPED
-        self._incoming = ssl.MemoryBIO()
-        self._outgoing = ssl.MemoryBIO()
-        self._sslobj = None
-        self._need_ssldata = False
-        self._handshake_cb = None
-        self._shutdown_cb = None
-
-    @property
-    def context(self):
-        """The SSL context passed to the constructor."""
-        return self._context
-
-    @property
-    def ssl_object(self):
-        """The internal ssl.SSLObject instance.
-
-        Return None if the pipe is not wrapped.
-        """
-        return self._sslobj
-
-    @property
-    def need_ssldata(self):
-        """Whether more record level data is needed to complete a handshake
-        that is currently in progress."""
-        return self._need_ssldata
-
-    @property
-    def wrapped(self):
-        """
-        Whether a security layer is currently in effect.
-
-        Return False during handshake.
-        """
-        return self._state == _WRAPPED
-
-    def do_handshake(self, callback=None):
-        """Start the SSL handshake.
-
-        Return a list of ssldata. A ssldata element is a list of buffers
-
-        The optional *callback* argument can be used to install a callback that
-        will be called when the handshake is complete. The callback will be
-        called with None if successful, else an exception instance.
-        """
-        if self._state != _UNWRAPPED:
-            raise RuntimeError("handshake in progress or completed")
-        self._sslobj = self._context.wrap_bio(
-            self._incoming,
-            self._outgoing,
-            server_side=self._server_side,
-            server_hostname=self._server_hostname,
-        )
-        self._state = _DO_HANDSHAKE
-        self._handshake_cb = callback
-        ssldata, appdata = self.feed_ssldata(b"", only_handshake=True)
-        assert len(appdata) == 0
-        return ssldata
-
-    def shutdown(self, callback=None):
-        """Start the SSL shutdown sequence.
-
-        Return a list of ssldata. A ssldata element is a list of buffers
-
-        The optional *callback* argument can be used to install a callback that
-        will be called when the shutdown is complete. The callback will be
-        called without arguments.
-        """
-        if self._state == _UNWRAPPED:
-            raise RuntimeError("no security layer present")
-        if self._state == _SHUTDOWN:
-            raise RuntimeError("shutdown in progress")
-        assert self._state in (_WRAPPED, _DO_HANDSHAKE)
-        self._state = _SHUTDOWN
-        self._shutdown_cb = callback
-        ssldata, appdata = self.feed_ssldata(b"")
-        assert appdata == [] or appdata == [b""]
-        return ssldata
-
-    def feed_eof(self):
-        """Send a potentially "ragged" EOF.
-
-        This method will raise an SSL_ERROR_EOF exception if the EOF is
-        unexpected.
-        """
-        self._incoming.write_eof()
-        ssldata, appdata = self.feed_ssldata(b"")
-        assert appdata == [] or appdata == [b""]
-
-    def feed_ssldata(self, data, only_handshake=False):
-        """Feed SSL record level data into the pipe.
-
-        The data must be a bytes instance. It is OK to send an empty bytes
-        instance. This can be used to get ssldata for a handshake initiated by
-        this endpoint.
-
-        Return a (ssldata, appdata) tuple. The ssldata element is a list of
-        buffers containing SSL data that needs to be sent to the remote SSL.
-
-        The appdata element is a list of buffers containing plaintext data that
-        needs to be forwarded to the application. The appdata list may contain
-        an empty buffer indicating an SSL "close_notify" alert. This alert must
-        be acknowledged by calling shutdown().
-        """
-        if self._state == _UNWRAPPED:
-            # If unwrapped, pass plaintext data straight through.
-            if data:
-                appdata = [data]
-            else:
-                appdata = []
-            return ([], appdata)
-
-        self._need_ssldata = False
-        if data:
-            self._incoming.write(data)
-
-        ssldata = []
-        appdata = []
-        try:
-            if self._state == _DO_HANDSHAKE:
-                # Call do_handshake() until it doesn't raise anymore.
-                self._sslobj.do_handshake()
-                self._state = _WRAPPED
-                if self._handshake_cb:
-                    self._handshake_cb(None)
-                if only_handshake:
-                    return (ssldata, appdata)
-                # Handshake done: execute the wrapped block
-
-            if self._state == _WRAPPED:
-                # Main state: read data from SSL until close_notify
-                while True:
-                    chunk = self._sslobj.read(self.max_size)
-                    appdata.append(chunk)
-                    if not chunk:  # close_notify
-                        break
-
-            elif self._state == _SHUTDOWN:
-                # Call shutdown() until it doesn't raise anymore.
-                self._sslobj.unwrap()
-                self._sslobj = None
-                self._state = _UNWRAPPED
-                if self._shutdown_cb:
-                    self._shutdown_cb()
-
-            elif self._state == _UNWRAPPED:
-                # Drain possible plaintext data after close_notify.
-                appdata.append(self._incoming.read())
-        except (ssl.SSLError, ssl.CertificateError) as exc:
-            exc_errno = getattr(exc, "errno", None)
-            if exc_errno not in (
-                ssl.SSL_ERROR_WANT_READ,
-                ssl.SSL_ERROR_WANT_WRITE,
-                ssl.SSL_ERROR_SYSCALL,
-            ):
-                if self._state == _DO_HANDSHAKE and self._handshake_cb:
-                    self._handshake_cb(exc)
-                raise
-            self._need_ssldata = exc_errno == ssl.SSL_ERROR_WANT_READ
-
-        # Check for record level data that needs to be sent back.
-        # Happens for the initial handshake and renegotiations.
-        if self._outgoing.pending:
-            ssldata.append(self._outgoing.read())
-        return (ssldata, appdata)
-
-    def feed_appdata(self, data, offset=0):
-        """Feed plaintext data into the pipe.
-
-        Return an (ssldata, offset) tuple. The ssldata element is a list of
-        buffers containing record level data that needs to be sent to the
-        remote SSL instance. The offset is the number of plaintext bytes that
-        were processed, which may be less than the length of data.
-
-        NOTE: In case of short writes, this call MUST be retried with the SAME
-        buffer passed into the *data* argument (i.e. the id() must be the
-        same). This is an OpenSSL requirement. A further particularity is that
-        a short write will always have offset == 0, because the _ssl module
-        does not enable partial writes. And even though the offset is zero,
-        there will still be encrypted data in ssldata.
-        """
-        assert 0 <= offset <= len(data)
-        if self._state == _UNWRAPPED:
-            # pass through data in unwrapped mode
-            if offset < len(data):
-                ssldata = [data[offset:]]
-            else:
-                ssldata = []
-            return (ssldata, len(data))
-
-        ssldata = []
-        view = memoryview(data)
-        while True:
-            self._need_ssldata = False
-            try:
-                if offset < len(view):
-                    offset += self._sslobj.write(view[offset:])
-            except ssl.SSLError as exc:
-                # It is not allowed to call write() after unwrap() until the
-                # close_notify is acknowledged. We return the condition to the
-                # caller as a short write.
-                exc_errno = getattr(exc, "errno", None)
-                if exc.reason == "PROTOCOL_IS_SHUTDOWN":
-                    exc_errno = exc.errno = ssl.SSL_ERROR_WANT_READ
-                if exc_errno not in (
-                    ssl.SSL_ERROR_WANT_READ,
-                    ssl.SSL_ERROR_WANT_WRITE,
-                    ssl.SSL_ERROR_SYSCALL,
-                ):
-                    raise
-                self._need_ssldata = exc_errno == ssl.SSL_ERROR_WANT_READ
-
-            # See if there's any record level data back for us.
-            if self._outgoing.pending:
-                ssldata.append(self._outgoing.read())
-            if offset == len(view) or self._need_ssldata:
-                break
-        return (ssldata, offset)
-
-
-class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport):
-
-    _sendfile_compatible = constants._SendfileMode.FALLBACK
-
-    def __init__(self, loop, ssl_protocol):
-        self._loop = loop
-        # SSLProtocol instance
-        self._ssl_protocol = ssl_protocol
-        self._closed = False
-
-    def get_extra_info(self, name, default=None):
-        """Get optional transport information."""
-        return self._ssl_protocol._get_extra_info(name, default)
-
-    def set_protocol(self, protocol):
-        self._ssl_protocol._set_app_protocol(protocol)
-
-    def get_protocol(self):
-        return self._ssl_protocol._app_protocol
-
-    def is_closing(self):
-        return self._closed
-
-    def close(self):
-        """Close the transport.
-
-        Buffered data will be flushed asynchronously.  No more data
-        will be received.  After all buffered data is flushed, the
-        protocol's connection_lost() method will (eventually) called
-        with None as its argument.
-        """
-        self._closed = True
-        self._ssl_protocol._start_shutdown()
-
-    def __del__(self):
-        if not self._closed:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self.close()
-
-    def is_reading(self):
-        tr = self._ssl_protocol._transport
-        if tr is None:
-            raise RuntimeError("SSL transport has not been initialized yet")
-        return tr.is_reading()
-
-    def pause_reading(self):
-        """Pause the receiving end.
-
-        No data will be passed to the protocol's data_received()
-        method until resume_reading() is called.
-        """
-        self._ssl_protocol._transport.pause_reading()
-
-    def resume_reading(self):
-        """Resume the receiving end.
-
-        Data received will once again be passed to the protocol's
-        data_received() method.
-        """
-        self._ssl_protocol._transport.resume_reading()
-
-    def set_write_buffer_limits(self, high=None, low=None):
-        """Set the high- and low-water limits for write flow control.
-
-        These two values control when to call the protocol's
-        pause_writing() and resume_writing() methods.  If specified,
-        the low-water limit must be less than or equal to the
-        high-water limit.  Neither value can be negative.
-
-        The defaults are implementation-specific.  If only the
-        high-water limit is given, the low-water limit defaults to an
-        implementation-specific value less than or equal to the
-        high-water limit.  Setting high to zero forces low to zero as
-        well, and causes pause_writing() to be called whenever the
-        buffer becomes non-empty.  Setting low to zero causes
-        resume_writing() to be called only once the buffer is empty.
-        Use of zero for either limit is generally sub-optimal as it
-        reduces opportunities for doing I/O and computation
-        concurrently.
-        """
-        self._ssl_protocol._transport.set_write_buffer_limits(high, low)
-
-    def get_write_buffer_size(self):
-        """Return the current size of the write buffer."""
-        return self._ssl_protocol._transport.get_write_buffer_size()
-
-    @property
-    def _protocol_paused(self):
-        # Required for sendfile fallback pause_writing/resume_writing logic
-        return self._ssl_protocol._transport._protocol_paused
-
-    def write(self, data):
-        """Write some data bytes to the transport.
-
-        This does not block; it buffers the data and arranges for it
-        to be sent out asynchronously.
-        """
-        if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(
-                f"data: expecting a bytes-like instance, " f"got {type(data).__name__}"
-            )
-        if not data:
-            return
-        self._ssl_protocol._write_appdata(data)
-
-    def can_write_eof(self):
-        """Return True if this transport supports write_eof(), False if not."""
-        return False
-
-    def abort(self):
-        """Close the transport immediately.
-
-        Buffered data will be lost.  No more data will be received.
-        The protocol's connection_lost() method will (eventually) be
-        called with None as its argument.
-        """
-        self._ssl_protocol._abort()
-        self._closed = True
-
-
-class SSLProtocol(protocols.Protocol):
-    """SSL protocol.
-
-    Implementation of SSL on top of a socket using incoming and outgoing
-    buffers which are ssl.MemoryBIO objects.
-    """
-
-    def __init__(
-        self,
-        loop,
-        app_protocol,
-        sslcontext,
-        waiter,
-        server_side=False,
-        server_hostname=None,
-        call_connection_made=True,
-        ssl_handshake_timeout=None,
-    ):
-        if ssl is None:
-            raise RuntimeError("stdlib ssl module not available")
-
-        if ssl_handshake_timeout is None:
-            ssl_handshake_timeout = constants.SSL_HANDSHAKE_TIMEOUT
-        elif ssl_handshake_timeout <= 0:
-            raise ValueError(
-                f"ssl_handshake_timeout should be a positive number, "
-                f"got {ssl_handshake_timeout}"
-            )
-
-        if not sslcontext:
-            sslcontext = _create_transport_context(server_side, server_hostname)
-
-        self._server_side = server_side
-        if server_hostname and not server_side:
-            self._server_hostname = server_hostname
-        else:
-            self._server_hostname = None
-        self._sslcontext = sslcontext
-        # SSL-specific extra info. More info are set when the handshake
-        # completes.
-        self._extra = dict(sslcontext=sslcontext)
-
-        # App data write buffering
-        self._write_backlog = collections.deque()
-        self._write_buffer_size = 0
-
-        self._waiter = waiter
-        self._loop = loop
-        self._set_app_protocol(app_protocol)
-        self._app_transport = _SSLProtocolTransport(self._loop, self)
-        # _SSLPipe instance (None until the connection is made)
-        self._sslpipe = None
-        self._session_established = False
-        self._in_handshake = False
-        self._in_shutdown = False
-        # transport, ex: SelectorSocketTransport
-        self._transport = None
-        self._call_connection_made = call_connection_made
-        self._ssl_handshake_timeout = ssl_handshake_timeout
-
-    def _set_app_protocol(self, app_protocol):
-        self._app_protocol = app_protocol
-        self._app_protocol_is_buffer = isinstance(
-            app_protocol, protocols.BufferedProtocol
-        )
-
-    def _wakeup_waiter(self, exc=None):
-        if self._waiter is None:
-            return
-        if not self._waiter.cancelled():
-            if exc is not None:
-                self._waiter.set_exception(exc)
-            else:
-                self._waiter.set_result(None)
-        self._waiter = None
-
-    def connection_made(self, transport):
-        """Called when the low-level connection is made.
-
-        Start the SSL handshake.
-        """
-        self._transport = transport
-        self._sslpipe = _SSLPipe(
-            self._sslcontext, self._server_side, self._server_hostname
-        )
-        self._start_handshake()
-
-    def connection_lost(self, exc):
-        """Called when the low-level connection is lost or closed.
-
-        The argument is an exception object or None (the latter
-        meaning a regular EOF is received or the connection was
-        aborted or closed).
-        """
-        if self._session_established:
-            self._session_established = False
-            self._loop.call_soon(self._app_protocol.connection_lost, exc)
-        else:
-            # Most likely an exception occurred while in SSL handshake.
-            # Just mark the app transport as closed so that its __del__
-            # doesn't complain.
-            if self._app_transport is not None:
-                self._app_transport._closed = True
-        self._transport = None
-        self._app_transport = None
-        if getattr(self, "_handshake_timeout_handle", None):
-            self._handshake_timeout_handle.cancel()
-        self._wakeup_waiter(exc)
-        self._app_protocol = None
-        self._sslpipe = None
-
-    def pause_writing(self):
-        """Called when the low-level transport's buffer goes over
-        the high-water mark.
-        """
-        self._app_protocol.pause_writing()
-
-    def resume_writing(self):
-        """Called when the low-level transport's buffer drains below
-        the low-water mark.
-        """
-        self._app_protocol.resume_writing()
-
-    def data_received(self, data):
-        """Called when some SSL data is received.
-
-        The argument is a bytes object.
-        """
-        if self._sslpipe is None:
-            # transport closing, sslpipe is destroyed
-            return
-
-        try:
-            ssldata, appdata = self._sslpipe.feed_ssldata(data)
-        except Exception as e:
-            self._fatal_error(e, "SSL error in data received")
-            return
-
-        for chunk in ssldata:
-            self._transport.write(chunk)
-
-        for chunk in appdata:
-            if chunk:
-                try:
-                    if self._app_protocol_is_buffer:
-                        protocols._feed_data_to_buffered_proto(
-                            self._app_protocol, chunk
-                        )
-                    else:
-                        self._app_protocol.data_received(chunk)
-                except Exception as ex:
-                    self._fatal_error(
-                        ex, "application protocol failed to receive SSL data"
-                    )
-                    return
-            else:
-                self._start_shutdown()
-                break
-
-    def eof_received(self):
-        """Called when the other end of the low-level stream
-        is half-closed.
-
-        If this returns a false value (including None), the transport
-        will close itself.  If it returns a true value, closing the
-        transport is up to the protocol.
-        """
-        try:
-            if self._loop.get_debug():
-                logger.debug("%r received EOF", self)
-
-            self._wakeup_waiter(ConnectionResetError)
-
-            if not self._in_handshake:
-                keep_open = self._app_protocol.eof_received()
-                if keep_open:
-                    logger.warning(
-                        "returning true from eof_received() "
-                        "has no effect when using ssl"
-                    )
-        finally:
-            self._transport.close()
-
-    def _get_extra_info(self, name, default=None):
-        if name in self._extra:
-            return self._extra[name]
-        elif self._transport is not None:
-            return self._transport.get_extra_info(name, default)
-        else:
-            return default
-
-    def _start_shutdown(self):
-        if self._in_shutdown:
-            return
-        if self._in_handshake:
-            self._abort()
-        else:
-            self._in_shutdown = True
-            self._write_appdata(b"")
-
-    def _write_appdata(self, data):
-        self._write_backlog.append((data, 0))
-        self._write_buffer_size += len(data)
-        self._process_write_backlog()
-
-    def _start_handshake(self):
-        if self._loop.get_debug():
-            logger.debug("%r starts SSL handshake", self)
-            self._handshake_start_time = self._loop.time()
-        else:
-            self._handshake_start_time = None
-        self._in_handshake = True
-        # (b'', 1) is a special value in _process_write_backlog() to do
-        # the SSL handshake
-        self._write_backlog.append((b"", 1))
-        self._handshake_timeout_handle = self._loop.call_later(
-            self._ssl_handshake_timeout, self._check_handshake_timeout
-        )
-        self._process_write_backlog()
-
-    def _check_handshake_timeout(self):
-        if self._in_handshake is True:
-            msg = (
-                f"SSL handshake is taking longer than "
-                f"{self._ssl_handshake_timeout} seconds: "
-                f"aborting the connection"
-            )
-            self._fatal_error(ConnectionAbortedError(msg))
-
-    def _on_handshake_complete(self, handshake_exc):
-        self._in_handshake = False
-        self._handshake_timeout_handle.cancel()
-
-        sslobj = self._sslpipe.ssl_object
-        try:
-            if handshake_exc is not None:
-                raise handshake_exc
-
-            peercert = sslobj.getpeercert()
-        except Exception as exc:
-            if isinstance(exc, ssl.CertificateError):
-                msg = "SSL handshake failed on verifying the certificate"
-            else:
-                msg = "SSL handshake failed"
-            self._fatal_error(exc, msg)
-            return
-
-        if self._loop.get_debug():
-            dt = self._loop.time() - self._handshake_start_time
-            logger.debug("%r: SSL handshake took %.1f ms", self, dt * 1e3)
-
-        # Add extra info that becomes available after handshake.
-        self._extra.update(
-            peercert=peercert,
-            cipher=sslobj.cipher(),
-            compression=sslobj.compression(),
-            ssl_object=sslobj,
-        )
-        if self._call_connection_made:
-            self._app_protocol.connection_made(self._app_transport)
-        self._wakeup_waiter()
-        self._session_established = True
-        # In case transport.write() was already called. Don't call
-        # immediately _process_write_backlog(), but schedule it:
-        # _on_handshake_complete() can be called indirectly from
-        # _process_write_backlog(), and _process_write_backlog() is not
-        # reentrant.
-        self._loop.call_soon(self._process_write_backlog)
-
-    def _process_write_backlog(self):
-        # Try to make progress on the write backlog.
-        if self._transport is None or self._sslpipe is None:
-            return
-
-        try:
-            for i in range(len(self._write_backlog)):
-                data, offset = self._write_backlog[0]
-                if data:
-                    ssldata, offset = self._sslpipe.feed_appdata(data, offset)
-                elif offset:
-                    ssldata = self._sslpipe.do_handshake(self._on_handshake_complete)
-                    offset = 1
-                else:
-                    ssldata = self._sslpipe.shutdown(self._finalize)
-                    offset = 1
-
-                for chunk in ssldata:
-                    self._transport.write(chunk)
-
-                if offset < len(data):
-                    self._write_backlog[0] = (data, offset)
-                    # A short write means that a write is blocked on a read
-                    # We need to enable reading if it is paused!
-                    assert self._sslpipe.need_ssldata
-                    if self._transport._paused:
-                        self._transport.resume_reading()
-                    break
-
-                # An entire chunk from the backlog was processed. We can
-                # delete it and reduce the outstanding buffer size.
-                del self._write_backlog[0]
-                self._write_buffer_size -= len(data)
-        except Exception as exc:
-            if self._in_handshake:
-                # Exceptions will be re-raised in _on_handshake_complete.
-                self._on_handshake_complete(exc)
-            else:
-                self._fatal_error(exc, "Fatal error on SSL transport")
-
-    def _fatal_error(self, exc, message="Fatal error on transport"):
-        if isinstance(exc, OSError):
-            if self._loop.get_debug():
-                logger.debug("%r: %s", self, message, exc_info=True)
-        else:
-            self._loop.call_exception_handler(
-                {
-                    "message": message,
-                    "exception": exc,
-                    "transport": self._transport,
-                    "protocol": self,
-                }
-            )
-        if self._transport:
-            self._transport._force_close(exc)
-
-    def _finalize(self):
-        self._sslpipe = None
-
-        if self._transport is not None:
-            self._transport.close()
-
-    def _abort(self):
-        try:
-            if self._transport is not None:
-                self._transport.abort()
-        finally:
-            self._finalize()
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/streams.py b/addon/globalPlugins/spellcheck/libs/asyncio/streams.py
deleted file mode 100644
index 69b7e3d..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/streams.py
+++ /dev/null
@@ -1,712 +0,0 @@
-__all__ = (
-    "StreamReader",
-    "StreamWriter",
-    "StreamReaderProtocol",
-    "open_connection",
-    "start_server",
-    "IncompleteReadError",
-    "LimitOverrunError",
-)
-
-import socket
-
-if hasattr(socket, "AF_UNIX"):
-    __all__ += ("open_unix_connection", "start_unix_server")
-
-from . import coroutines
-from . import events
-from . import protocols
-from .log import logger
-from .tasks import sleep
-
-
-_DEFAULT_LIMIT = 2 ** 16  # 64 KiB
-
-
-class IncompleteReadError(EOFError):
-    """
-    Incomplete read error. Attributes:
-
-    - partial: read bytes string before the end of stream was reached
-    - expected: total number of expected bytes (or None if unknown)
-    """
-
-    def __init__(self, partial, expected):
-        super().__init__(
-            f"{len(partial)} bytes read on a total of " f"{expected!r} expected bytes"
-        )
-        self.partial = partial
-        self.expected = expected
-
-    def __reduce__(self):
-        return type(self), (self.partial, self.expected)
-
-
-class LimitOverrunError(Exception):
-    """Reached the buffer limit while looking for a separator.
-
-    Attributes:
-    - consumed: total number of to be consumed bytes.
-    """
-
-    def __init__(self, message, consumed):
-        super().__init__(message)
-        self.consumed = consumed
-
-    def __reduce__(self):
-        return type(self), (self.args[0], self.consumed)
-
-
-async def open_connection(
-    host=None, port=None, *, loop=None, limit=_DEFAULT_LIMIT, **kwds
-):
-    """A wrapper for create_connection() returning a (reader, writer) pair.
-
-    The reader returned is a StreamReader instance; the writer is a
-    StreamWriter instance.
-
-    The arguments are all the usual arguments to create_connection()
-    except protocol_factory; most common are positional host and port,
-    with various optional keyword arguments following.
-
-    Additional optional keyword arguments are loop (to set the event loop
-    instance to use) and limit (to set the buffer limit passed to the
-    StreamReader).
-
-    (If you want to customize the StreamReader and/or
-    StreamReaderProtocol classes, just copy the code -- there's
-    really nothing special here except some convenience.)
-    """
-    if loop is None:
-        loop = events.get_event_loop()
-    reader = StreamReader(limit=limit, loop=loop)
-    protocol = StreamReaderProtocol(reader, loop=loop)
-    transport, _ = await loop.create_connection(lambda: protocol, host, port, **kwds)
-    writer = StreamWriter(transport, protocol, reader, loop)
-    return reader, writer
-
-
-async def start_server(
-    client_connected_cb,
-    host=None,
-    port=None,
-    *,
-    loop=None,
-    limit=_DEFAULT_LIMIT,
-    **kwds,
-):
-    """Start a socket server, call back for each client connected.
-
-    The first parameter, `client_connected_cb`, takes two parameters:
-    client_reader, client_writer.  client_reader is a StreamReader
-    object, while client_writer is a StreamWriter object.  This
-    parameter can either be a plain callback function or a coroutine;
-    if it is a coroutine, it will be automatically converted into a
-    Task.
-
-    The rest of the arguments are all the usual arguments to
-    loop.create_server() except protocol_factory; most common are
-    positional host and port, with various optional keyword arguments
-    following.  The return value is the same as loop.create_server().
-
-    Additional optional keyword arguments are loop (to set the event loop
-    instance to use) and limit (to set the buffer limit passed to the
-    StreamReader).
-
-    The return value is the same as loop.create_server(), i.e. a
-    Server object which can be used to stop the service.
-    """
-    if loop is None:
-        loop = events.get_event_loop()
-
-    def factory():
-        reader = StreamReader(limit=limit, loop=loop)
-        protocol = StreamReaderProtocol(reader, client_connected_cb, loop=loop)
-        return protocol
-
-    return await loop.create_server(factory, host, port, **kwds)
-
-
-if hasattr(socket, "AF_UNIX"):
-    # UNIX Domain Sockets are supported on this platform
-
-    async def open_unix_connection(
-        path=None, *, loop=None, limit=_DEFAULT_LIMIT, **kwds
-    ):
-        """Similar to `open_connection` but works with UNIX Domain Sockets."""
-        if loop is None:
-            loop = events.get_event_loop()
-        reader = StreamReader(limit=limit, loop=loop)
-        protocol = StreamReaderProtocol(reader, loop=loop)
-        transport, _ = await loop.create_unix_connection(lambda: protocol, path, **kwds)
-        writer = StreamWriter(transport, protocol, reader, loop)
-        return reader, writer
-
-    async def start_unix_server(
-        client_connected_cb, path=None, *, loop=None, limit=_DEFAULT_LIMIT, **kwds
-    ):
-        """Similar to `start_server` but works with UNIX Domain Sockets."""
-        if loop is None:
-            loop = events.get_event_loop()
-
-        def factory():
-            reader = StreamReader(limit=limit, loop=loop)
-            protocol = StreamReaderProtocol(reader, client_connected_cb, loop=loop)
-            return protocol
-
-        return await loop.create_unix_server(factory, path, **kwds)
-
-
-class FlowControlMixin(protocols.Protocol):
-    """Reusable flow control logic for StreamWriter.drain().
-
-    This implements the protocol methods pause_writing(),
-    resume_writing() and connection_lost().  If the subclass overrides
-    these it must call the super methods.
-
-    StreamWriter.drain() must wait for _drain_helper() coroutine.
-    """
-
-    def __init__(self, loop=None):
-        if loop is None:
-            self._loop = events.get_event_loop()
-        else:
-            self._loop = loop
-        self._paused = False
-        self._drain_waiter = None
-        self._connection_lost = False
-
-    def pause_writing(self):
-        assert not self._paused
-        self._paused = True
-        if self._loop.get_debug():
-            logger.debug("%r pauses writing", self)
-
-    def resume_writing(self):
-        assert self._paused
-        self._paused = False
-        if self._loop.get_debug():
-            logger.debug("%r resumes writing", self)
-
-        waiter = self._drain_waiter
-        if waiter is not None:
-            self._drain_waiter = None
-            if not waiter.done():
-                waiter.set_result(None)
-
-    def connection_lost(self, exc):
-        self._connection_lost = True
-        # Wake up the writer if currently paused.
-        if not self._paused:
-            return
-        waiter = self._drain_waiter
-        if waiter is None:
-            return
-        self._drain_waiter = None
-        if waiter.done():
-            return
-        if exc is None:
-            waiter.set_result(None)
-        else:
-            waiter.set_exception(exc)
-
-    async def _drain_helper(self):
-        if self._connection_lost:
-            raise ConnectionResetError("Connection lost")
-        if not self._paused:
-            return
-        waiter = self._drain_waiter
-        assert waiter is None or waiter.cancelled()
-        waiter = self._loop.create_future()
-        self._drain_waiter = waiter
-        await waiter
-
-
-class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
-    """Helper class to adapt between Protocol and StreamReader.
-
-    (This is a helper class instead of making StreamReader itself a
-    Protocol subclass, because the StreamReader has other potential
-    uses, and to prevent the user of the StreamReader to accidentally
-    call inappropriate methods of the protocol.)
-    """
-
-    def __init__(self, stream_reader, client_connected_cb=None, loop=None):
-        super().__init__(loop=loop)
-        self._stream_reader = stream_reader
-        self._stream_writer = None
-        self._client_connected_cb = client_connected_cb
-        self._over_ssl = False
-        self._closed = self._loop.create_future()
-
-    def connection_made(self, transport):
-        self._stream_reader.set_transport(transport)
-        self._over_ssl = transport.get_extra_info("sslcontext") is not None
-        if self._client_connected_cb is not None:
-            self._stream_writer = StreamWriter(
-                transport, self, self._stream_reader, self._loop
-            )
-            res = self._client_connected_cb(self._stream_reader, self._stream_writer)
-            if coroutines.iscoroutine(res):
-                self._loop.create_task(res)
-
-    def connection_lost(self, exc):
-        if self._stream_reader is not None:
-            if exc is None:
-                self._stream_reader.feed_eof()
-            else:
-                self._stream_reader.set_exception(exc)
-        if not self._closed.done():
-            if exc is None:
-                self._closed.set_result(None)
-            else:
-                self._closed.set_exception(exc)
-        super().connection_lost(exc)
-        self._stream_reader = None
-        self._stream_writer = None
-
-    def data_received(self, data):
-        self._stream_reader.feed_data(data)
-
-    def eof_received(self):
-        self._stream_reader.feed_eof()
-        if self._over_ssl:
-            # Prevent a warning in SSLProtocol.eof_received:
-            # "returning true from eof_received()
-            # has no effect when using ssl"
-            return False
-        return True
-
-    def __del__(self):
-        # Prevent reports about unhandled exceptions.
-        # Better than self._closed._log_traceback = False hack
-        closed = self._closed
-        if closed.done() and not closed.cancelled():
-            closed.exception()
-
-
-class StreamWriter:
-    """Wraps a Transport.
-
-    This exposes write(), writelines(), [can_]write_eof(),
-    get_extra_info() and close().  It adds drain() which returns an
-    optional Future on which you can wait for flow control.  It also
-    adds a transport property which references the Transport
-    directly.
-    """
-
-    def __init__(self, transport, protocol, reader, loop):
-        self._transport = transport
-        self._protocol = protocol
-        # drain() expects that the reader has an exception() method
-        assert reader is None or isinstance(reader, StreamReader)
-        self._reader = reader
-        self._loop = loop
-
-    def __repr__(self):
-        info = [self.__class__.__name__, f"transport={self._transport!r}"]
-        if self._reader is not None:
-            info.append(f"reader={self._reader!r}")
-        return "<{}>".format(" ".join(info))
-
-    @property
-    def transport(self):
-        return self._transport
-
-    def write(self, data):
-        self._transport.write(data)
-
-    def writelines(self, data):
-        self._transport.writelines(data)
-
-    def write_eof(self):
-        return self._transport.write_eof()
-
-    def can_write_eof(self):
-        return self._transport.can_write_eof()
-
-    def close(self):
-        return self._transport.close()
-
-    def is_closing(self):
-        return self._transport.is_closing()
-
-    async def wait_closed(self):
-        await self._protocol._closed
-
-    def get_extra_info(self, name, default=None):
-        return self._transport.get_extra_info(name, default)
-
-    async def drain(self):
-        """Flush the write buffer.
-
-        The intended use is to write
-
-          w.write(data)
-          await w.drain()
-        """
-        if self._reader is not None:
-            exc = self._reader.exception()
-            if exc is not None:
-                raise exc
-        if self._transport.is_closing():
-            # Yield to the event loop so connection_lost() may be
-            # called.  Without this, _drain_helper() would return
-            # immediately, and code that calls
-            #     write(...); await drain()
-            # in a loop would never call connection_lost(), so it
-            # would not see an error when the socket is closed.
-            await sleep(0, loop=self._loop)
-        await self._protocol._drain_helper()
-
-
-class StreamReader:
-    def __init__(self, limit=_DEFAULT_LIMIT, loop=None):
-        # The line length limit is  a security feature;
-        # it also doubles as half the buffer limit.
-
-        if limit <= 0:
-            raise ValueError("Limit cannot be <= 0")
-
-        self._limit = limit
-        if loop is None:
-            self._loop = events.get_event_loop()
-        else:
-            self._loop = loop
-        self._buffer = bytearray()
-        self._eof = False  # Whether we're done.
-        self._waiter = None  # A future used by _wait_for_data()
-        self._exception = None
-        self._transport = None
-        self._paused = False
-
-    def __repr__(self):
-        info = ["StreamReader"]
-        if self._buffer:
-            info.append(f"{len(self._buffer)} bytes")
-        if self._eof:
-            info.append("eof")
-        if self._limit != _DEFAULT_LIMIT:
-            info.append(f"limit={self._limit}")
-        if self._waiter:
-            info.append(f"waiter={self._waiter!r}")
-        if self._exception:
-            info.append(f"exception={self._exception!r}")
-        if self._transport:
-            info.append(f"transport={self._transport!r}")
-        if self._paused:
-            info.append("paused")
-        return "<{}>".format(" ".join(info))
-
-    def exception(self):
-        return self._exception
-
-    def set_exception(self, exc):
-        self._exception = exc
-
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            if not waiter.cancelled():
-                waiter.set_exception(exc)
-
-    def _wakeup_waiter(self):
-        """Wakeup read*() functions waiting for data or EOF."""
-        waiter = self._waiter
-        if waiter is not None:
-            self._waiter = None
-            if not waiter.cancelled():
-                waiter.set_result(None)
-
-    def set_transport(self, transport):
-        assert self._transport is None, "Transport already set"
-        self._transport = transport
-
-    def _maybe_resume_transport(self):
-        if self._paused and len(self._buffer) <= self._limit:
-            self._paused = False
-            self._transport.resume_reading()
-
-    def feed_eof(self):
-        self._eof = True
-        self._wakeup_waiter()
-
-    def at_eof(self):
-        """Return True if the buffer is empty and 'feed_eof' was called."""
-        return self._eof and not self._buffer
-
-    def feed_data(self, data):
-        assert not self._eof, "feed_data after feed_eof"
-
-        if not data:
-            return
-
-        self._buffer.extend(data)
-        self._wakeup_waiter()
-
-        if (
-            self._transport is not None
-            and not self._paused
-            and len(self._buffer) > 2 * self._limit
-        ):
-            try:
-                self._transport.pause_reading()
-            except NotImplementedError:
-                # The transport can't be paused.
-                # We'll just have to buffer all data.
-                # Forget the transport so we don't keep trying.
-                self._transport = None
-            else:
-                self._paused = True
-
-    async def _wait_for_data(self, func_name):
-        """Wait until feed_data() or feed_eof() is called.
-
-        If stream was paused, automatically resume it.
-        """
-        # StreamReader uses a future to link the protocol feed_data() method
-        # to a read coroutine. Running two read coroutines at the same time
-        # would have an unexpected behaviour. It would not possible to know
-        # which coroutine would get the next data.
-        if self._waiter is not None:
-            raise RuntimeError(
-                f"{func_name}() called while another coroutine is "
-                f"already waiting for incoming data"
-            )
-
-        assert not self._eof, "_wait_for_data after EOF"
-
-        # Waiting for data while paused will make deadlock, so prevent it.
-        # This is essential for readexactly(n) for case when n > self._limit.
-        if self._paused:
-            self._paused = False
-            self._transport.resume_reading()
-
-        self._waiter = self._loop.create_future()
-        try:
-            await self._waiter
-        finally:
-            self._waiter = None
-
-    async def readline(self):
-        """Read chunk of data from the stream until newline (b'\n') is found.
-
-        On success, return chunk that ends with newline. If only partial
-        line can be read due to EOF, return incomplete line without
-        terminating newline. When EOF was reached while no bytes read, empty
-        bytes object is returned.
-
-        If limit is reached, ValueError will be raised. In that case, if
-        newline was found, complete line including newline will be removed
-        from internal buffer. Else, internal buffer will be cleared. Limit is
-        compared against part of the line without newline.
-
-        If stream was paused, this function will automatically resume it if
-        needed.
-        """
-        sep = b"\n"
-        seplen = len(sep)
-        try:
-            line = await self.readuntil(sep)
-        except IncompleteReadError as e:
-            return e.partial
-        except LimitOverrunError as e:
-            if self._buffer.startswith(sep, e.consumed):
-                del self._buffer[: e.consumed + seplen]
-            else:
-                self._buffer.clear()
-            self._maybe_resume_transport()
-            raise ValueError(e.args[0])
-        return line
-
-    async def readuntil(self, separator=b"\n"):
-        """Read data from the stream until ``separator`` is found.
-
-        On success, the data and separator will be removed from the
-        internal buffer (consumed). Returned data will include the
-        separator at the end.
-
-        Configured stream limit is used to check result. Limit sets the
-        maximal length of data that can be returned, not counting the
-        separator.
-
-        If an EOF occurs and the complete separator is still not found,
-        an IncompleteReadError exception will be raised, and the internal
-        buffer will be reset.  The IncompleteReadError.partial attribute
-        may contain the separator partially.
-
-        If the data cannot be read because of over limit, a
-        LimitOverrunError exception  will be raised, and the data
-        will be left in the internal buffer, so it can be read again.
-        """
-        seplen = len(separator)
-        if seplen == 0:
-            raise ValueError("Separator should be at least one-byte string")
-
-        if self._exception is not None:
-            raise self._exception
-
-        # Consume whole buffer except last bytes, which length is
-        # one less than seplen. Let's check corner cases with
-        # separator='SEPARATOR':
-        # * we have received almost complete separator (without last
-        #   byte). i.e buffer='some textSEPARATO'. In this case we
-        #   can safely consume len(separator) - 1 bytes.
-        # * last byte of buffer is first byte of separator, i.e.
-        #   buffer='abcdefghijklmnopqrS'. We may safely consume
-        #   everything except that last byte, but this require to
-        #   analyze bytes of buffer that match partial separator.
-        #   This is slow and/or require FSM. For this case our
-        #   implementation is not optimal, since require rescanning
-        #   of data that is known to not belong to separator. In
-        #   real world, separator will not be so long to notice
-        #   performance problems. Even when reading MIME-encoded
-        #   messages :)
-
-        # `offset` is the number of bytes from the beginning of the buffer
-        # where there is no occurrence of `separator`.
-        offset = 0
-
-        # Loop until we find `separator` in the buffer, exceed the buffer size,
-        # or an EOF has happened.
-        while True:
-            buflen = len(self._buffer)
-
-            # Check if we now have enough data in the buffer for `separator` to
-            # fit.
-            if buflen - offset >= seplen:
-                isep = self._buffer.find(separator, offset)
-
-                if isep != -1:
-                    # `separator` is in the buffer. `isep` will be used later
-                    # to retrieve the data.
-                    break
-
-                # see upper comment for explanation.
-                offset = buflen + 1 - seplen
-                if offset > self._limit:
-                    raise LimitOverrunError(
-                        "Separator is not found, and chunk exceed the limit", offset
-                    )
-
-            # Complete message (with full separator) may be present in buffer
-            # even when EOF flag is set. This may happen when the last chunk
-            # adds data which makes separator be found. That's why we check for
-            # EOF *ater* inspecting the buffer.
-            if self._eof:
-                chunk = bytes(self._buffer)
-                self._buffer.clear()
-                raise IncompleteReadError(chunk, None)
-
-            # _wait_for_data() will resume reading if stream was paused.
-            await self._wait_for_data("readuntil")
-
-        if isep > self._limit:
-            raise LimitOverrunError(
-                "Separator is found, but chunk is longer than limit", isep
-            )
-
-        chunk = self._buffer[: isep + seplen]
-        del self._buffer[: isep + seplen]
-        self._maybe_resume_transport()
-        return bytes(chunk)
-
-    async def read(self, n=-1):
-        """Read up to `n` bytes from the stream.
-
-        If n is not provided, or set to -1, read until EOF and return all read
-        bytes. If the EOF was received and the internal buffer is empty, return
-        an empty bytes object.
-
-        If n is zero, return empty bytes object immediately.
-
-        If n is positive, this function try to read `n` bytes, and may return
-        less or equal bytes than requested, but at least one byte. If EOF was
-        received before any byte is read, this function returns empty byte
-        object.
-
-        Returned value is not limited with limit, configured at stream
-        creation.
-
-        If stream was paused, this function will automatically resume it if
-        needed.
-        """
-
-        if self._exception is not None:
-            raise self._exception
-
-        if n == 0:
-            return b""
-
-        if n < 0:
-            # This used to just loop creating a new waiter hoping to
-            # collect everything in self._buffer, but that would
-            # deadlock if the subprocess sends more than self.limit
-            # bytes.  So just call self.read(self._limit) until EOF.
-            blocks = []
-            while True:
-                block = await self.read(self._limit)
-                if not block:
-                    break
-                blocks.append(block)
-            return b"".join(blocks)
-
-        if not self._buffer and not self._eof:
-            await self._wait_for_data("read")
-
-        # This will work right even if buffer is less than n bytes
-        data = bytes(self._buffer[:n])
-        del self._buffer[:n]
-
-        self._maybe_resume_transport()
-        return data
-
-    async def readexactly(self, n):
-        """Read exactly `n` bytes.
-
-        Raise an IncompleteReadError if EOF is reached before `n` bytes can be
-        read. The IncompleteReadError.partial attribute of the exception will
-        contain the partial read bytes.
-
-        if n is zero, return empty bytes object.
-
-        Returned value is not limited with limit, configured at stream
-        creation.
-
-        If stream was paused, this function will automatically resume it if
-        needed.
-        """
-        if n < 0:
-            raise ValueError("readexactly size can not be less than zero")
-
-        if self._exception is not None:
-            raise self._exception
-
-        if n == 0:
-            return b""
-
-        while len(self._buffer) < n:
-            if self._eof:
-                incomplete = bytes(self._buffer)
-                self._buffer.clear()
-                raise IncompleteReadError(incomplete, n)
-
-            await self._wait_for_data("readexactly")
-
-        if len(self._buffer) == n:
-            data = bytes(self._buffer)
-            self._buffer.clear()
-        else:
-            data = bytes(self._buffer[:n])
-            del self._buffer[:n]
-        self._maybe_resume_transport()
-        return data
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        val = await self.readline()
-        if val == b"":
-            raise StopAsyncIteration
-        return val
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/subprocess.py b/addon/globalPlugins/spellcheck/libs/asyncio/subprocess.py
deleted file mode 100644
index 513495b..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/subprocess.py
+++ /dev/null
@@ -1,228 +0,0 @@
-__all__ = "create_subprocess_exec", "create_subprocess_shell"
-
-import subprocess
-
-from . import events
-from . import protocols
-from . import streams
-from . import tasks
-from .log import logger
-
-
-PIPE = subprocess.PIPE
-STDOUT = subprocess.STDOUT
-DEVNULL = subprocess.DEVNULL
-
-
-class SubprocessStreamProtocol(streams.FlowControlMixin, protocols.SubprocessProtocol):
-    """Like StreamReaderProtocol, but for a subprocess."""
-
-    def __init__(self, limit, loop):
-        super().__init__(loop=loop)
-        self._limit = limit
-        self.stdin = self.stdout = self.stderr = None
-        self._transport = None
-        self._process_exited = False
-        self._pipe_fds = []
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self.stdin is not None:
-            info.append(f"stdin={self.stdin!r}")
-        if self.stdout is not None:
-            info.append(f"stdout={self.stdout!r}")
-        if self.stderr is not None:
-            info.append(f"stderr={self.stderr!r}")
-        return "<{}>".format(" ".join(info))
-
-    def connection_made(self, transport):
-        self._transport = transport
-
-        stdout_transport = transport.get_pipe_transport(1)
-        if stdout_transport is not None:
-            self.stdout = streams.StreamReader(limit=self._limit, loop=self._loop)
-            self.stdout.set_transport(stdout_transport)
-            self._pipe_fds.append(1)
-
-        stderr_transport = transport.get_pipe_transport(2)
-        if stderr_transport is not None:
-            self.stderr = streams.StreamReader(limit=self._limit, loop=self._loop)
-            self.stderr.set_transport(stderr_transport)
-            self._pipe_fds.append(2)
-
-        stdin_transport = transport.get_pipe_transport(0)
-        if stdin_transport is not None:
-            self.stdin = streams.StreamWriter(
-                stdin_transport, protocol=self, reader=None, loop=self._loop
-            )
-
-    def pipe_data_received(self, fd, data):
-        if fd == 1:
-            reader = self.stdout
-        elif fd == 2:
-            reader = self.stderr
-        else:
-            reader = None
-        if reader is not None:
-            reader.feed_data(data)
-
-    def pipe_connection_lost(self, fd, exc):
-        if fd == 0:
-            pipe = self.stdin
-            if pipe is not None:
-                pipe.close()
-            self.connection_lost(exc)
-            return
-        if fd == 1:
-            reader = self.stdout
-        elif fd == 2:
-            reader = self.stderr
-        else:
-            reader = None
-        if reader is not None:
-            if exc is None:
-                reader.feed_eof()
-            else:
-                reader.set_exception(exc)
-
-        if fd in self._pipe_fds:
-            self._pipe_fds.remove(fd)
-        self._maybe_close_transport()
-
-    def process_exited(self):
-        self._process_exited = True
-        self._maybe_close_transport()
-
-    def _maybe_close_transport(self):
-        if len(self._pipe_fds) == 0 and self._process_exited:
-            self._transport.close()
-            self._transport = None
-
-
-class Process:
-    def __init__(self, transport, protocol, loop):
-        self._transport = transport
-        self._protocol = protocol
-        self._loop = loop
-        self.stdin = protocol.stdin
-        self.stdout = protocol.stdout
-        self.stderr = protocol.stderr
-        self.pid = transport.get_pid()
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__} {self.pid}>"
-
-    @property
-    def returncode(self):
-        return self._transport.get_returncode()
-
-    async def wait(self):
-        """Wait until the process exit and return the process return code."""
-        return await self._transport._wait()
-
-    def send_signal(self, signal):
-        self._transport.send_signal(signal)
-
-    def terminate(self):
-        self._transport.terminate()
-
-    def kill(self):
-        self._transport.kill()
-
-    async def _feed_stdin(self, input):
-        debug = self._loop.get_debug()
-        self.stdin.write(input)
-        if debug:
-            logger.debug("%r communicate: feed stdin (%s bytes)", self, len(input))
-        try:
-            await self.stdin.drain()
-        except (BrokenPipeError, ConnectionResetError) as exc:
-            # communicate() ignores BrokenPipeError and ConnectionResetError
-            if debug:
-                logger.debug("%r communicate: stdin got %r", self, exc)
-
-        if debug:
-            logger.debug("%r communicate: close stdin", self)
-        self.stdin.close()
-
-    async def _noop(self):
-        return None
-
-    async def _read_stream(self, fd):
-        transport = self._transport.get_pipe_transport(fd)
-        if fd == 2:
-            stream = self.stderr
-        else:
-            assert fd == 1
-            stream = self.stdout
-        if self._loop.get_debug():
-            name = "stdout" if fd == 1 else "stderr"
-            logger.debug("%r communicate: read %s", self, name)
-        output = await stream.read()
-        if self._loop.get_debug():
-            name = "stdout" if fd == 1 else "stderr"
-            logger.debug("%r communicate: close %s", self, name)
-        transport.close()
-        return output
-
-    async def communicate(self, input=None):
-        if input is not None:
-            stdin = self._feed_stdin(input)
-        else:
-            stdin = self._noop()
-        if self.stdout is not None:
-            stdout = self._read_stream(1)
-        else:
-            stdout = self._noop()
-        if self.stderr is not None:
-            stderr = self._read_stream(2)
-        else:
-            stderr = self._noop()
-        stdin, stdout, stderr = await tasks.gather(
-            stdin, stdout, stderr, loop=self._loop
-        )
-        await self.wait()
-        return (stdout, stderr)
-
-
-async def create_subprocess_shell(
-    cmd,
-    stdin=None,
-    stdout=None,
-    stderr=None,
-    loop=None,
-    limit=streams._DEFAULT_LIMIT,
-    **kwds,
-):
-    if loop is None:
-        loop = events.get_event_loop()
-    protocol_factory = lambda: SubprocessStreamProtocol(limit=limit, loop=loop)
-    transport, protocol = await loop.subprocess_shell(
-        protocol_factory, cmd, stdin=stdin, stdout=stdout, stderr=stderr, **kwds
-    )
-    return Process(transport, protocol, loop)
-
-
-async def create_subprocess_exec(
-    program,
-    *args,
-    stdin=None,
-    stdout=None,
-    stderr=None,
-    loop=None,
-    limit=streams._DEFAULT_LIMIT,
-    **kwds,
-):
-    if loop is None:
-        loop = events.get_event_loop()
-    protocol_factory = lambda: SubprocessStreamProtocol(limit=limit, loop=loop)
-    transport, protocol = await loop.subprocess_exec(
-        protocol_factory,
-        program,
-        *args,
-        stdin=stdin,
-        stdout=stdout,
-        stderr=stderr,
-        **kwds,
-    )
-    return Process(transport, protocol, loop)
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/tasks.py b/addon/globalPlugins/spellcheck/libs/asyncio/tasks.py
deleted file mode 100644
index 2259aa0..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/tasks.py
+++ /dev/null
@@ -1,919 +0,0 @@
-"""Support for tasks, coroutines and the scheduler."""
-
-__all__ = (
-    "Task",
-    "create_task",
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "wait",
-    "wait_for",
-    "as_completed",
-    "sleep",
-    "gather",
-    "shield",
-    "ensure_future",
-    "run_coroutine_threadsafe",
-    "current_task",
-    "all_tasks",
-    "_register_task",
-    "_unregister_task",
-    "_enter_task",
-    "_leave_task",
-)
-
-import concurrent.futures
-import contextvars
-import functools
-import inspect
-import types
-import warnings
-import weakref
-
-from . import base_tasks
-from . import coroutines
-from . import events
-from . import futures
-from .coroutines import coroutine
-
-
-def current_task(loop=None):
-    """Return a currently executed task."""
-    if loop is None:
-        loop = events.get_running_loop()
-    return _current_tasks.get(loop)
-
-
-def all_tasks(loop=None):
-    """Return a set of all tasks for the loop."""
-    if loop is None:
-        loop = events.get_running_loop()
-    # Looping over a WeakSet (_all_tasks) isn't safe as it can be updated from another
-    # thread while we do so. Therefore we cast it to list prior to filtering. The list
-    # cast itself requires iteration, so we repeat it several times ignoring
-    # RuntimeErrors (which are not very likely to occur). See issues 34970 and 36607 for
-    # details.
-    i = 0
-    while True:
-        try:
-            tasks = list(_all_tasks)
-        except RuntimeError:
-            i += 1
-            if i >= 1000:
-                raise
-        else:
-            break
-    return {t for t in tasks if futures._get_loop(t) is loop and not t.done()}
-
-
-def _all_tasks_compat(loop=None):
-    # Different from "all_task()" by returning *all* Tasks, including
-    # the completed ones.  Used to implement deprecated "Tasks.all_task()"
-    # method.
-    if loop is None:
-        loop = events.get_event_loop()
-    # Looping over a WeakSet (_all_tasks) isn't safe as it can be updated from another
-    # thread while we do so. Therefore we cast it to list prior to filtering. The list
-    # cast itself requires iteration, so we repeat it several times ignoring
-    # RuntimeErrors (which are not very likely to occur). See issues 34970 and 36607 for
-    # details.
-    i = 0
-    while True:
-        try:
-            tasks = list(_all_tasks)
-        except RuntimeError:
-            i += 1
-            if i >= 1000:
-                raise
-        else:
-            break
-    return {t for t in tasks if futures._get_loop(t) is loop}
-
-
-class Task(futures._PyFuture):  # Inherit Python Task implementation
-    # from a Python Future implementation.
-
-    """A coroutine wrapped in a Future."""
-
-    # An important invariant maintained while a Task not done:
-    #
-    # - Either _fut_waiter is None, and _step() is scheduled;
-    # - or _fut_waiter is some Future, and _step() is *not* scheduled.
-    #
-    # The only transition from the latter to the former is through
-    # _wakeup().  When _fut_waiter is not None, one of its callbacks
-    # must be _wakeup().
-
-    # If False, don't log a message if the task is destroyed whereas its
-    # status is still pending
-    _log_destroy_pending = True
-
-    @classmethod
-    def current_task(cls, loop=None):
-        """Return the currently running task in an event loop or None.
-
-        By default the current task for the current event loop is returned.
-
-        None is returned when called not in the context of a Task.
-        """
-        warnings.warn(
-            "Task.current_task() is deprecated, " "use asyncio.current_task() instead",
-            PendingDeprecationWarning,
-            stacklevel=2,
-        )
-        if loop is None:
-            loop = events.get_event_loop()
-        return current_task(loop)
-
-    @classmethod
-    def all_tasks(cls, loop=None):
-        """Return a set of all tasks for an event loop.
-
-        By default all tasks for the current event loop are returned.
-        """
-        warnings.warn(
-            "Task.all_tasks() is deprecated, " "use asyncio.all_tasks() instead",
-            PendingDeprecationWarning,
-            stacklevel=2,
-        )
-        return _all_tasks_compat(loop)
-
-    def __init__(self, coro, *, loop=None):
-        super().__init__(loop=loop)
-        if self._source_traceback:
-            del self._source_traceback[-1]
-        if not coroutines.iscoroutine(coro):
-            # raise after Future.__init__(), attrs are required for __del__
-            # prevent logging for pending task in __del__
-            self._log_destroy_pending = False
-            raise TypeError(f"a coroutine was expected, got {coro!r}")
-
-        self._must_cancel = False
-        self._fut_waiter = None
-        self._coro = coro
-        self._context = contextvars.copy_context()
-
-        self._loop.call_soon(self.__step, context=self._context)
-        _register_task(self)
-
-    def __del__(self):
-        if self._state == futures._PENDING and self._log_destroy_pending:
-            context = {
-                "task": self,
-                "message": "Task was destroyed but it is pending!",
-            }
-            if self._source_traceback:
-                context["source_traceback"] = self._source_traceback
-            self._loop.call_exception_handler(context)
-        super().__del__()
-
-    def _repr_info(self):
-        return base_tasks._task_repr_info(self)
-
-    def set_result(self, result):
-        raise RuntimeError("Task does not support set_result operation")
-
-    def set_exception(self, exception):
-        raise RuntimeError("Task does not support set_exception operation")
-
-    def get_stack(self, *, limit=None):
-        """Return the list of stack frames for this task's coroutine.
-
-        If the coroutine is not done, this returns the stack where it is
-        suspended.  If the coroutine has completed successfully or was
-        cancelled, this returns an empty list.  If the coroutine was
-        terminated by an exception, this returns the list of traceback
-        frames.
-
-        The frames are always ordered from oldest to newest.
-
-        The optional limit gives the maximum number of frames to
-        return; by default all available frames are returned.  Its
-        meaning differs depending on whether a stack or a traceback is
-        returned: the newest frames of a stack are returned, but the
-        oldest frames of a traceback are returned.  (This matches the
-        behavior of the traceback module.)
-
-        For reasons beyond our control, only one stack frame is
-        returned for a suspended coroutine.
-        """
-        return base_tasks._task_get_stack(self, limit)
-
-    def print_stack(self, *, limit=None, file=None):
-        """Print the stack or traceback for this task's coroutine.
-
-        This produces output similar to that of the traceback module,
-        for the frames retrieved by get_stack().  The limit argument
-        is passed to get_stack().  The file argument is an I/O stream
-        to which the output is written; by default output is written
-        to sys.stderr.
-        """
-        return base_tasks._task_print_stack(self, limit, file)
-
-    def cancel(self):
-        """Request that this task cancel itself.
-
-        This arranges for a CancelledError to be thrown into the
-        wrapped coroutine on the next cycle through the event loop.
-        The coroutine then has a chance to clean up or even deny
-        the request using try/except/finally.
-
-        Unlike Future.cancel, this does not guarantee that the
-        task will be cancelled: the exception might be caught and
-        acted upon, delaying cancellation of the task or preventing
-        cancellation completely.  The task may also return a value or
-        raise a different exception.
-
-        Immediately after this method is called, Task.cancelled() will
-        not return True (unless the task was already cancelled).  A
-        task will be marked as cancelled when the wrapped coroutine
-        terminates with a CancelledError exception (even if cancel()
-        was not called).
-        """
-        self._log_traceback = False
-        if self.done():
-            return False
-        if self._fut_waiter is not None:
-            if self._fut_waiter.cancel():
-                # Leave self._fut_waiter; it may be a Task that
-                # catches and ignores the cancellation so we may have
-                # to cancel it again later.
-                return True
-        # It must be the case that self.__step is already scheduled.
-        self._must_cancel = True
-        return True
-
-    def __step(self, exc=None):
-        if self.done():
-            raise futures.InvalidStateError(f"_step(): already done: {self!r}, {exc!r}")
-        if self._must_cancel:
-            if not isinstance(exc, futures.CancelledError):
-                exc = futures.CancelledError()
-            self._must_cancel = False
-        coro = self._coro
-        self._fut_waiter = None
-
-        _enter_task(self._loop, self)
-        # Call either coro.throw(exc) or coro.send(None).
-        try:
-            if exc is None:
-                # We use the `send` method directly, because coroutines
-                # don't have `__iter__` and `__next__` methods.
-                result = coro.send(None)
-            else:
-                result = coro.throw(exc)
-        except StopIteration as exc:
-            if self._must_cancel:
-                # Task is cancelled right before coro stops.
-                self._must_cancel = False
-                super().set_exception(futures.CancelledError())
-            else:
-                super().set_result(exc.value)
-        except futures.CancelledError:
-            super().cancel()  # I.e., Future.cancel(self).
-        except Exception as exc:
-            super().set_exception(exc)
-        except BaseException as exc:
-            super().set_exception(exc)
-            raise
-        else:
-            blocking = getattr(result, "_asyncio_future_blocking", None)
-            if blocking is not None:
-                # Yielded Future must come from Future.__iter__().
-                if futures._get_loop(result) is not self._loop:
-                    new_exc = RuntimeError(
-                        f"Task {self!r} got Future "
-                        f"{result!r} attached to a different loop"
-                    )
-                    self._loop.call_soon(self.__step, new_exc, context=self._context)
-                elif blocking:
-                    if result is self:
-                        new_exc = RuntimeError(f"Task cannot await on itself: {self!r}")
-                        self._loop.call_soon(
-                            self.__step, new_exc, context=self._context
-                        )
-                    else:
-                        result._asyncio_future_blocking = False
-                        result.add_done_callback(self.__wakeup, context=self._context)
-                        self._fut_waiter = result
-                        if self._must_cancel:
-                            if self._fut_waiter.cancel():
-                                self._must_cancel = False
-                else:
-                    new_exc = RuntimeError(
-                        f"yield was used instead of yield from "
-                        f"in task {self!r} with {result!r}"
-                    )
-                    self._loop.call_soon(self.__step, new_exc, context=self._context)
-
-            elif result is None:
-                # Bare yield relinquishes control for one event loop iteration.
-                self._loop.call_soon(self.__step, context=self._context)
-            elif inspect.isgenerator(result):
-                # Yielding a generator is just wrong.
-                new_exc = RuntimeError(
-                    f"yield was used instead of yield from for "
-                    f"generator in task {self!r} with {result!r}"
-                )
-                self._loop.call_soon(self.__step, new_exc, context=self._context)
-            else:
-                # Yielding something else is an error.
-                new_exc = RuntimeError(f"Task got bad yield: {result!r}")
-                self._loop.call_soon(self.__step, new_exc, context=self._context)
-        finally:
-            _leave_task(self._loop, self)
-            self = None  # Needed to break cycles when an exception occurs.
-
-    def __wakeup(self, future):
-        try:
-            future.result()
-        except Exception as exc:
-            # This may also be a cancellation.
-            self.__step(exc)
-        else:
-            # Don't pass the value of `future.result()` explicitly,
-            # as `Future.__iter__` and `Future.__await__` don't need it.
-            # If we call `_step(value, None)` instead of `_step()`,
-            # Python eval loop would use `.send(value)` method call,
-            # instead of `__next__()`, which is slower for futures
-            # that return non-generator iterators from their `__iter__`.
-            self.__step()
-        self = None  # Needed to break cycles when an exception occurs.
-
-
-_PyTask = Task
-
-
-try:
-    import _asyncio
-except ImportError:
-    pass
-else:
-    # _CTask is needed for tests.
-    Task = _CTask = _asyncio.Task
-
-
-def create_task(coro):
-    """Schedule the execution of a coroutine object in a spawn task.
-
-    Return a Task object.
-    """
-    loop = events.get_running_loop()
-    return loop.create_task(coro)
-
-
-# wait() and as_completed() similar to those in PEP 3148.
-
-FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED
-FIRST_EXCEPTION = concurrent.futures.FIRST_EXCEPTION
-ALL_COMPLETED = concurrent.futures.ALL_COMPLETED
-
-
-async def wait(fs, *, loop=None, timeout=None, return_when=ALL_COMPLETED):
-    """Wait for the Futures and coroutines given by fs to complete.
-
-    The sequence futures must not be empty.
-
-    Coroutines will be wrapped in Tasks.
-
-    Returns two sets of Future: (done, pending).
-
-    Usage:
-
-        done, pending = await asyncio.wait(fs)
-
-    Note: This does not raise TimeoutError! Futures that aren't done
-    when the timeout occurs are returned in the second set.
-    """
-    if futures.isfuture(fs) or coroutines.iscoroutine(fs):
-        raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
-    if not fs:
-        raise ValueError("Set of coroutines/Futures is empty.")
-    if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
-        raise ValueError(f"Invalid return_when value: {return_when}")
-
-    if loop is None:
-        loop = events.get_event_loop()
-
-    fs = {ensure_future(f, loop=loop) for f in set(fs)}
-
-    return await _wait(fs, timeout, return_when, loop)
-
-
-def _release_waiter(waiter, *args):
-    if not waiter.done():
-        waiter.set_result(None)
-
-
-async def wait_for(fut, timeout, *, loop=None):
-    """Wait for the single Future or coroutine to complete, with timeout.
-
-    Coroutine will be wrapped in Task.
-
-    Returns result of the Future or coroutine.  When a timeout occurs,
-    it cancels the task and raises TimeoutError.  To avoid the task
-    cancellation, wrap it in shield().
-
-    If the wait is cancelled, the task is also cancelled.
-
-    This function is a coroutine.
-    """
-    if loop is None:
-        loop = events.get_event_loop()
-
-    if timeout is None:
-        return await fut
-
-    if timeout <= 0:
-        fut = ensure_future(fut, loop=loop)
-
-        if fut.done():
-            return fut.result()
-
-        fut.cancel()
-        raise futures.TimeoutError()
-
-    waiter = loop.create_future()
-    timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
-    cb = functools.partial(_release_waiter, waiter)
-
-    fut = ensure_future(fut, loop=loop)
-    fut.add_done_callback(cb)
-
-    try:
-        # wait until the future completes or the timeout
-        try:
-            await waiter
-        except futures.CancelledError:
-            fut.remove_done_callback(cb)
-            fut.cancel()
-            raise
-
-        if fut.done():
-            return fut.result()
-        else:
-            fut.remove_done_callback(cb)
-            # We must ensure that the task is not running
-            # after wait_for() returns.
-            # See https://bugs.python.org/issue32751
-            await _cancel_and_wait(fut, loop=loop)
-            raise futures.TimeoutError()
-    finally:
-        timeout_handle.cancel()
-
-
-async def _wait(fs, timeout, return_when, loop):
-    """Internal helper for wait().
-
-    The fs argument must be a collection of Futures.
-    """
-    assert fs, "Set of Futures is empty."
-    waiter = loop.create_future()
-    timeout_handle = None
-    if timeout is not None:
-        timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
-    counter = len(fs)
-
-    def _on_completion(f):
-        nonlocal counter
-        counter -= 1
-        if (
-            counter <= 0
-            or return_when == FIRST_COMPLETED
-            or return_when == FIRST_EXCEPTION
-            and (not f.cancelled() and f.exception() is not None)
-        ):
-            if timeout_handle is not None:
-                timeout_handle.cancel()
-            if not waiter.done():
-                waiter.set_result(None)
-
-    for f in fs:
-        f.add_done_callback(_on_completion)
-
-    try:
-        await waiter
-    finally:
-        if timeout_handle is not None:
-            timeout_handle.cancel()
-        for f in fs:
-            f.remove_done_callback(_on_completion)
-
-    done, pending = set(), set()
-    for f in fs:
-        if f.done():
-            done.add(f)
-        else:
-            pending.add(f)
-    return done, pending
-
-
-async def _cancel_and_wait(fut, loop):
-    """Cancel the *fut* future or task and wait until it completes."""
-
-    waiter = loop.create_future()
-    cb = functools.partial(_release_waiter, waiter)
-    fut.add_done_callback(cb)
-
-    try:
-        fut.cancel()
-        # We cannot wait on *fut* directly to make
-        # sure _cancel_and_wait itself is reliably cancellable.
-        await waiter
-    finally:
-        fut.remove_done_callback(cb)
-
-
-# This is *not* a @coroutine!  It is just an iterator (yielding Futures).
-def as_completed(fs, *, loop=None, timeout=None):
-    """Return an iterator whose values are coroutines.
-
-    When waiting for the yielded coroutines you'll get the results (or
-    exceptions!) of the original Futures (or coroutines), in the order
-    in which and as soon as they complete.
-
-    This differs from PEP 3148; the proper way to use this is:
-
-        for f in as_completed(fs):
-            result = await f  # The 'await' may raise.
-            # Use result.
-
-    If a timeout is specified, the 'await' will raise
-    TimeoutError when the timeout occurs before all Futures are done.
-
-    Note: The futures 'f' are not necessarily members of fs.
-    """
-    if futures.isfuture(fs) or coroutines.iscoroutine(fs):
-        raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
-    loop = loop if loop is not None else events.get_event_loop()
-    todo = {ensure_future(f, loop=loop) for f in set(fs)}
-    from .queues import Queue  # Import here to avoid circular import problem.
-
-    done = Queue(loop=loop)
-    timeout_handle = None
-
-    def _on_timeout():
-        for f in todo:
-            f.remove_done_callback(_on_completion)
-            done.put_nowait(None)  # Queue a dummy value for _wait_for_one().
-        todo.clear()  # Can't do todo.remove(f) in the loop.
-
-    def _on_completion(f):
-        if not todo:
-            return  # _on_timeout() was here first.
-        todo.remove(f)
-        done.put_nowait(f)
-        if not todo and timeout_handle is not None:
-            timeout_handle.cancel()
-
-    async def _wait_for_one():
-        f = await done.get()
-        if f is None:
-            # Dummy value from _on_timeout().
-            raise futures.TimeoutError
-        return f.result()  # May raise f.exception().
-
-    for f in todo:
-        f.add_done_callback(_on_completion)
-    if todo and timeout is not None:
-        timeout_handle = loop.call_later(timeout, _on_timeout)
-    for _ in range(len(todo)):
-        yield _wait_for_one()
-
-
-@types.coroutine
-def __sleep0():
-    """Skip one event loop run cycle.
-
-    This is a private helper for 'asyncio.sleep()', used
-    when the 'delay' is set to 0.  It uses a bare 'yield'
-    expression (which Task.__step knows how to handle)
-    instead of creating a Future object.
-    """
-    yield
-
-
-async def sleep(delay, result=None, *, loop=None):
-    """Coroutine that completes after a given time (in seconds)."""
-    if delay <= 0:
-        await __sleep0()
-        return result
-
-    if loop is None:
-        loop = events.get_event_loop()
-    future = loop.create_future()
-    h = loop.call_later(delay, futures._set_result_unless_cancelled, future, result)
-    try:
-        return await future
-    finally:
-        h.cancel()
-
-
-def ensure_future(coro_or_future, *, loop=None):
-    """Wrap a coroutine or an awaitable in a future.
-
-    If the argument is a Future, it is returned directly.
-    """
-    if coroutines.iscoroutine(coro_or_future):
-        if loop is None:
-            loop = events.get_event_loop()
-        task = loop.create_task(coro_or_future)
-        if task._source_traceback:
-            del task._source_traceback[-1]
-        return task
-    elif futures.isfuture(coro_or_future):
-        if loop is not None and loop is not futures._get_loop(coro_or_future):
-            raise ValueError("loop argument must agree with Future")
-        return coro_or_future
-    elif inspect.isawaitable(coro_or_future):
-        return ensure_future(_wrap_awaitable(coro_or_future), loop=loop)
-    else:
-        raise TypeError("An asyncio.Future, a coroutine or an awaitable is " "required")
-
-
-@coroutine
-def _wrap_awaitable(awaitable):
-    """Helper for asyncio.ensure_future().
-
-    Wraps awaitable (an object with __await__) into a coroutine
-    that will later be wrapped in a Task by ensure_future().
-    """
-    return (yield from awaitable.__await__())
-
-
-class _GatheringFuture(futures.Future):
-    """Helper for gather().
-
-    This overrides cancel() to cancel all the children and act more
-    like Task.cancel(), which doesn't immediately mark itself as
-    cancelled.
-    """
-
-    def __init__(self, children, *, loop=None):
-        super().__init__(loop=loop)
-        self._children = children
-        self._cancel_requested = False
-
-    def cancel(self):
-        if self.done():
-            return False
-        ret = False
-        for child in self._children:
-            if child.cancel():
-                ret = True
-        if ret:
-            # If any child tasks were actually cancelled, we should
-            # propagate the cancellation request regardless of
-            # *return_exceptions* argument.  See issue 32684.
-            self._cancel_requested = True
-        return ret
-
-
-def gather(*coros_or_futures, loop=None, return_exceptions=False):
-    """Return a future aggregating results from the given coroutines/futures.
-
-    Coroutines will be wrapped in a future and scheduled in the event
-    loop. They will not necessarily be scheduled in the same order as
-    passed in.
-
-    All futures must share the same event loop.  If all the tasks are
-    done successfully, the returned future's result is the list of
-    results (in the order of the original sequence, not necessarily
-    the order of results arrival).  If *return_exceptions* is True,
-    exceptions in the tasks are treated the same as successful
-    results, and gathered in the result list; otherwise, the first
-    raised exception will be immediately propagated to the returned
-    future.
-
-    Cancellation: if the outer Future is cancelled, all children (that
-    have not completed yet) are also cancelled.  If any child is
-    cancelled, this is treated as if it raised CancelledError --
-    the outer Future is *not* cancelled in this case.  (This is to
-    prevent the cancellation of one child to cause other children to
-    be cancelled.)
-    """
-    if not coros_or_futures:
-        if loop is None:
-            loop = events.get_event_loop()
-        outer = loop.create_future()
-        outer.set_result([])
-        return outer
-
-    def _done_callback(fut):
-        nonlocal nfinished
-        nfinished += 1
-
-        if outer.done():
-            if not fut.cancelled():
-                # Mark exception retrieved.
-                fut.exception()
-            return
-
-        if not return_exceptions:
-            if fut.cancelled():
-                # Check if 'fut' is cancelled first, as
-                # 'fut.exception()' will *raise* a CancelledError
-                # instead of returning it.
-                exc = futures.CancelledError()
-                outer.set_exception(exc)
-                return
-            else:
-                exc = fut.exception()
-                if exc is not None:
-                    outer.set_exception(exc)
-                    return
-
-        if nfinished == nfuts:
-            # All futures are done; create a list of results
-            # and set it to the 'outer' future.
-            results = []
-
-            for fut in children:
-                if fut.cancelled():
-                    # Check if 'fut' is cancelled first, as
-                    # 'fut.exception()' will *raise* a CancelledError
-                    # instead of returning it.
-                    res = futures.CancelledError()
-                else:
-                    res = fut.exception()
-                    if res is None:
-                        res = fut.result()
-                results.append(res)
-
-            if outer._cancel_requested:
-                # If gather is being cancelled we must propagate the
-                # cancellation regardless of *return_exceptions* argument.
-                # See issue 32684.
-                outer.set_exception(futures.CancelledError())
-            else:
-                outer.set_result(results)
-
-    arg_to_fut = {}
-    children = []
-    nfuts = 0
-    nfinished = 0
-    for arg in coros_or_futures:
-        if arg not in arg_to_fut:
-            fut = ensure_future(arg, loop=loop)
-            if loop is None:
-                loop = futures._get_loop(fut)
-            if fut is not arg:
-                # 'arg' was not a Future, therefore, 'fut' is a new
-                # Future created specifically for 'arg'.  Since the caller
-                # can't control it, disable the "destroy pending task"
-                # warning.
-                fut._log_destroy_pending = False
-
-            nfuts += 1
-            arg_to_fut[arg] = fut
-            fut.add_done_callback(_done_callback)
-
-        else:
-            # There's a duplicate Future object in coros_or_futures.
-            fut = arg_to_fut[arg]
-
-        children.append(fut)
-
-    outer = _GatheringFuture(children, loop=loop)
-    return outer
-
-
-def shield(arg, *, loop=None):
-    """Wait for a future, shielding it from cancellation.
-
-    The statement
-
-        res = await shield(something())
-
-    is exactly equivalent to the statement
-
-        res = await something()
-
-    *except* that if the coroutine containing it is cancelled, the
-    task running in something() is not cancelled.  From the POV of
-    something(), the cancellation did not happen.  But its caller is
-    still cancelled, so the yield-from expression still raises
-    CancelledError.  Note: If something() is cancelled by other means
-    this will still cancel shield().
-
-    If you want to completely ignore cancellation (not recommended)
-    you can combine shield() with a try/except clause, as follows:
-
-        try:
-            res = await shield(something())
-        except CancelledError:
-            res = None
-    """
-    inner = ensure_future(arg, loop=loop)
-    if inner.done():
-        # Shortcut.
-        return inner
-    loop = futures._get_loop(inner)
-    outer = loop.create_future()
-
-    def _inner_done_callback(inner):
-        if outer.cancelled():
-            if not inner.cancelled():
-                # Mark inner's result as retrieved.
-                inner.exception()
-            return
-
-        if inner.cancelled():
-            outer.cancel()
-        else:
-            exc = inner.exception()
-            if exc is not None:
-                outer.set_exception(exc)
-            else:
-                outer.set_result(inner.result())
-
-    def _outer_done_callback(outer):
-        if not inner.done():
-            inner.remove_done_callback(_inner_done_callback)
-
-    inner.add_done_callback(_inner_done_callback)
-    outer.add_done_callback(_outer_done_callback)
-    return outer
-
-
-def run_coroutine_threadsafe(coro, loop):
-    """Submit a coroutine object to a given event loop.
-
-    Return a concurrent.futures.Future to access the result.
-    """
-    if not coroutines.iscoroutine(coro):
-        raise TypeError("A coroutine object is required")
-    future = concurrent.futures.Future()
-
-    def callback():
-        try:
-            futures._chain_future(ensure_future(coro, loop=loop), future)
-        except Exception as exc:
-            if future.set_running_or_notify_cancel():
-                future.set_exception(exc)
-            raise
-
-    loop.call_soon_threadsafe(callback)
-    return future
-
-
-# WeakSet containing all alive tasks.
-_all_tasks = weakref.WeakSet()
-
-# Dictionary containing tasks that are currently active in
-# all running event loops.  {EventLoop: Task}
-_current_tasks = {}
-
-
-def _register_task(task):
-    """Register a new task in asyncio as executed by loop."""
-    _all_tasks.add(task)
-
-
-def _enter_task(loop, task):
-    current_task = _current_tasks.get(loop)
-    if current_task is not None:
-        raise RuntimeError(
-            f"Cannot enter into task {task!r} while another "
-            f"task {current_task!r} is being executed."
-        )
-    _current_tasks[loop] = task
-
-
-def _leave_task(loop, task):
-    current_task = _current_tasks.get(loop)
-    if current_task is not task:
-        raise RuntimeError(
-            f"Leaving task {task!r} does not match "
-            f"the current task {current_task!r}."
-        )
-    del _current_tasks[loop]
-
-
-def _unregister_task(task):
-    """Unregister a task."""
-    _all_tasks.discard(task)
-
-
-_py_register_task = _register_task
-_py_unregister_task = _unregister_task
-_py_enter_task = _enter_task
-_py_leave_task = _leave_task
-
-
-try:
-    from _asyncio import (
-        _register_task,
-        _unregister_task,
-        _enter_task,
-        _leave_task,
-        _all_tasks,
-        _current_tasks,
-    )
-except ImportError:
-    pass
-else:
-    _c_register_task = _register_task
-    _c_unregister_task = _unregister_task
-    _c_enter_task = _enter_task
-    _c_leave_task = _leave_task
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/transports.py b/addon/globalPlugins/spellcheck/libs/asyncio/transports.py
deleted file mode 100644
index 57b268e..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/transports.py
+++ /dev/null
@@ -1,316 +0,0 @@
-"""Abstract Transport class."""
-
-__all__ = (
-    "BaseTransport",
-    "ReadTransport",
-    "WriteTransport",
-    "Transport",
-    "DatagramTransport",
-    "SubprocessTransport",
-)
-
-
-class BaseTransport:
-    """Base class for transports."""
-
-    def __init__(self, extra=None):
-        if extra is None:
-            extra = {}
-        self._extra = extra
-
-    def get_extra_info(self, name, default=None):
-        """Get optional transport information."""
-        return self._extra.get(name, default)
-
-    def is_closing(self):
-        """Return True if the transport is closing or closed."""
-        raise NotImplementedError
-
-    def close(self):
-        """Close the transport.
-
-        Buffered data will be flushed asynchronously.  No more data
-        will be received.  After all buffered data is flushed, the
-        protocol's connection_lost() method will (eventually) called
-        with None as its argument.
-        """
-        raise NotImplementedError
-
-    def set_protocol(self, protocol):
-        """Set a new protocol."""
-        raise NotImplementedError
-
-    def get_protocol(self):
-        """Return the current protocol."""
-        raise NotImplementedError
-
-
-class ReadTransport(BaseTransport):
-    """Interface for read-only transports."""
-
-    def is_reading(self):
-        """Return True if the transport is receiving."""
-        raise NotImplementedError
-
-    def pause_reading(self):
-        """Pause the receiving end.
-
-        No data will be passed to the protocol's data_received()
-        method until resume_reading() is called.
-        """
-        raise NotImplementedError
-
-    def resume_reading(self):
-        """Resume the receiving end.
-
-        Data received will once again be passed to the protocol's
-        data_received() method.
-        """
-        raise NotImplementedError
-
-
-class WriteTransport(BaseTransport):
-    """Interface for write-only transports."""
-
-    def set_write_buffer_limits(self, high=None, low=None):
-        """Set the high- and low-water limits for write flow control.
-
-        These two values control when to call the protocol's
-        pause_writing() and resume_writing() methods.  If specified,
-        the low-water limit must be less than or equal to the
-        high-water limit.  Neither value can be negative.
-
-        The defaults are implementation-specific.  If only the
-        high-water limit is given, the low-water limit defaults to an
-        implementation-specific value less than or equal to the
-        high-water limit.  Setting high to zero forces low to zero as
-        well, and causes pause_writing() to be called whenever the
-        buffer becomes non-empty.  Setting low to zero causes
-        resume_writing() to be called only once the buffer is empty.
-        Use of zero for either limit is generally sub-optimal as it
-        reduces opportunities for doing I/O and computation
-        concurrently.
-        """
-        raise NotImplementedError
-
-    def get_write_buffer_size(self):
-        """Return the current size of the write buffer."""
-        raise NotImplementedError
-
-    def write(self, data):
-        """Write some data bytes to the transport.
-
-        This does not block; it buffers the data and arranges for it
-        to be sent out asynchronously.
-        """
-        raise NotImplementedError
-
-    def writelines(self, list_of_data):
-        """Write a list (or any iterable) of data bytes to the transport.
-
-        The default implementation concatenates the arguments and
-        calls write() on the result.
-        """
-        data = b"".join(list_of_data)
-        self.write(data)
-
-    def write_eof(self):
-        """Close the write end after flushing buffered data.
-
-        (This is like typing ^D into a UNIX program reading from stdin.)
-
-        Data may still be received.
-        """
-        raise NotImplementedError
-
-    def can_write_eof(self):
-        """Return True if this transport supports write_eof(), False if not."""
-        raise NotImplementedError
-
-    def abort(self):
-        """Close the transport immediately.
-
-        Buffered data will be lost.  No more data will be received.
-        The protocol's connection_lost() method will (eventually) be
-        called with None as its argument.
-        """
-        raise NotImplementedError
-
-
-class Transport(ReadTransport, WriteTransport):
-    """Interface representing a bidirectional transport.
-
-    There may be several implementations, but typically, the user does
-    not implement new transports; rather, the platform provides some
-    useful transports that are implemented using the platform's best
-    practices.
-
-    The user never instantiates a transport directly; they call a
-    utility function, passing it a protocol factory and other
-    information necessary to create the transport and protocol.  (E.g.
-    EventLoop.create_connection() or EventLoop.create_server().)
-
-    The utility function will asynchronously create a transport and a
-    protocol and hook them up by calling the protocol's
-    connection_made() method, passing it the transport.
-
-    The implementation here raises NotImplemented for every method
-    except writelines(), which calls write() in a loop.
-    """
-
-
-class DatagramTransport(BaseTransport):
-    """Interface for datagram (UDP) transports."""
-
-    def sendto(self, data, addr=None):
-        """Send data to the transport.
-
-        This does not block; it buffers the data and arranges for it
-        to be sent out asynchronously.
-        addr is target socket address.
-        If addr is None use target address pointed on transport creation.
-        """
-        raise NotImplementedError
-
-    def abort(self):
-        """Close the transport immediately.
-
-        Buffered data will be lost.  No more data will be received.
-        The protocol's connection_lost() method will (eventually) be
-        called with None as its argument.
-        """
-        raise NotImplementedError
-
-
-class SubprocessTransport(BaseTransport):
-    def get_pid(self):
-        """Get subprocess id."""
-        raise NotImplementedError
-
-    def get_returncode(self):
-        """Get subprocess returncode.
-
-        See also
-        http://docs.python.org/3/library/subprocess#subprocess.Popen.returncode
-        """
-        raise NotImplementedError
-
-    def get_pipe_transport(self, fd):
-        """Get transport for pipe with number fd."""
-        raise NotImplementedError
-
-    def send_signal(self, signal):
-        """Send signal to subprocess.
-
-        See also:
-        docs.python.org/3/library/subprocess#subprocess.Popen.send_signal
-        """
-        raise NotImplementedError
-
-    def terminate(self):
-        """Stop the subprocess.
-
-        Alias for close() method.
-
-        On Posix OSs the method sends SIGTERM to the subprocess.
-        On Windows the Win32 API function TerminateProcess()
-         is called to stop the subprocess.
-
-        See also:
-        http://docs.python.org/3/library/subprocess#subprocess.Popen.terminate
-        """
-        raise NotImplementedError
-
-    def kill(self):
-        """Kill the subprocess.
-
-        On Posix OSs the function sends SIGKILL to the subprocess.
-        On Windows kill() is an alias for terminate().
-
-        See also:
-        http://docs.python.org/3/library/subprocess#subprocess.Popen.kill
-        """
-        raise NotImplementedError
-
-
-class _FlowControlMixin(Transport):
-    """All the logic for (write) flow control in a mix-in base class.
-
-    The subclass must implement get_write_buffer_size().  It must call
-    _maybe_pause_protocol() whenever the write buffer size increases,
-    and _maybe_resume_protocol() whenever it decreases.  It may also
-    override set_write_buffer_limits() (e.g. to specify different
-    defaults).
-
-    The subclass constructor must call super().__init__(extra).  This
-    will call set_write_buffer_limits().
-
-    The user may call set_write_buffer_limits() and
-    get_write_buffer_size(), and their protocol's pause_writing() and
-    resume_writing() may be called.
-    """
-
-    def __init__(self, extra=None, loop=None):
-        super().__init__(extra)
-        assert loop is not None
-        self._loop = loop
-        self._protocol_paused = False
-        self._set_write_buffer_limits()
-
-    def _maybe_pause_protocol(self):
-        size = self.get_write_buffer_size()
-        if size <= self._high_water:
-            return
-        if not self._protocol_paused:
-            self._protocol_paused = True
-            try:
-                self._protocol.pause_writing()
-            except Exception as exc:
-                self._loop.call_exception_handler(
-                    {
-                        "message": "protocol.pause_writing() failed",
-                        "exception": exc,
-                        "transport": self,
-                        "protocol": self._protocol,
-                    }
-                )
-
-    def _maybe_resume_protocol(self):
-        if self._protocol_paused and self.get_write_buffer_size() <= self._low_water:
-            self._protocol_paused = False
-            try:
-                self._protocol.resume_writing()
-            except Exception as exc:
-                self._loop.call_exception_handler(
-                    {
-                        "message": "protocol.resume_writing() failed",
-                        "exception": exc,
-                        "transport": self,
-                        "protocol": self._protocol,
-                    }
-                )
-
-    def get_write_buffer_limits(self):
-        return (self._low_water, self._high_water)
-
-    def _set_write_buffer_limits(self, high=None, low=None):
-        if high is None:
-            if low is None:
-                high = 64 * 1024
-            else:
-                high = 4 * low
-        if low is None:
-            low = high // 4
-
-        if not high >= low >= 0:
-            raise ValueError(f"high ({high!r}) must be >= low ({low!r}) must be >= 0")
-
-        self._high_water = high
-        self._low_water = low
-
-    def set_write_buffer_limits(self, high=None, low=None):
-        self._set_write_buffer_limits(high=high, low=low)
-        self._maybe_pause_protocol()
-
-    def get_write_buffer_size(self):
-        raise NotImplementedError
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/unix_events.py b/addon/globalPlugins/spellcheck/libs/asyncio/unix_events.py
deleted file mode 100644
index 8f8507a..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/unix_events.py
+++ /dev/null
@@ -1,1227 +0,0 @@
-"""Selector event loop for Unix with signal handling."""
-
-import errno
-import io
-import os
-import selectors
-import signal
-import socket
-import stat
-import subprocess
-import sys
-import threading
-import warnings
-
-
-from . import base_events
-from . import base_subprocess
-from . import constants
-from . import coroutines
-from . import events
-from . import futures
-from . import selector_events
-from . import tasks
-from . import transports
-from .log import logger
-
-
-__all__ = (
-    "SelectorEventLoop",
-    "AbstractChildWatcher",
-    "SafeChildWatcher",
-    "FastChildWatcher",
-    "DefaultEventLoopPolicy",
-)
-
-
-if sys.platform == "win32":  # pragma: no cover
-    raise ImportError("Signals are not really supported on Windows")
-
-
-def _sighandler_noop(signum, frame):
-    """Dummy signal handler."""
-    pass
-
-
-class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
-    """Unix event loop.
-
-    Adds signal handling and UNIX Domain Socket support to SelectorEventLoop.
-    """
-
-    def __init__(self, selector=None):
-        super().__init__(selector)
-        self._signal_handlers = {}
-
-    def close(self):
-        super().close()
-        if not sys.is_finalizing():
-            for sig in list(self._signal_handlers):
-                self.remove_signal_handler(sig)
-        else:
-            if self._signal_handlers:
-                warnings.warn(
-                    f"Closing the loop {self!r} "
-                    f"on interpreter shutdown "
-                    f"stage, skipping signal handlers removal",
-                    ResourceWarning,
-                    source=self,
-                )
-                self._signal_handlers.clear()
-
-    def _process_self_data(self, data):
-        for signum in data:
-            if not signum:
-                # ignore null bytes written by _write_to_self()
-                continue
-            self._handle_signal(signum)
-
-    def add_signal_handler(self, sig, callback, *args):
-        """Add a handler for a signal.  UNIX only.
-
-        Raise ValueError if the signal number is invalid or uncatchable.
-        Raise RuntimeError if there is a problem setting up the handler.
-        """
-        if coroutines.iscoroutine(callback) or coroutines.iscoroutinefunction(callback):
-            raise TypeError("coroutines cannot be used " "with add_signal_handler()")
-        self._check_signal(sig)
-        self._check_closed()
-        try:
-            # set_wakeup_fd() raises ValueError if this is not the
-            # main thread.  By calling it early we ensure that an
-            # event loop running in another thread cannot add a signal
-            # handler.
-            signal.set_wakeup_fd(self._csock.fileno())
-        except (ValueError, OSError) as exc:
-            raise RuntimeError(str(exc))
-
-        handle = events.Handle(callback, args, self, None)
-        self._signal_handlers[sig] = handle
-
-        try:
-            # Register a dummy signal handler to ask Python to write the signal
-            # number in the wakeup file descriptor. _process_self_data() will
-            # read signal numbers from this file descriptor to handle signals.
-            signal.signal(sig, _sighandler_noop)
-
-            # Set SA_RESTART to limit EINTR occurrences.
-            signal.siginterrupt(sig, False)
-        except OSError as exc:
-            del self._signal_handlers[sig]
-            if not self._signal_handlers:
-                try:
-                    signal.set_wakeup_fd(-1)
-                except (ValueError, OSError) as nexc:
-                    logger.info("set_wakeup_fd(-1) failed: %s", nexc)
-
-            if exc.errno == errno.EINVAL:
-                raise RuntimeError(f"sig {sig} cannot be caught")
-            else:
-                raise
-
-    def _handle_signal(self, sig):
-        """Internal helper that is the actual signal handler."""
-        handle = self._signal_handlers.get(sig)
-        if handle is None:
-            return  # Assume it's some race condition.
-        if handle._cancelled:
-            self.remove_signal_handler(sig)  # Remove it properly.
-        else:
-            self._add_callback_signalsafe(handle)
-
-    def remove_signal_handler(self, sig):
-        """Remove a handler for a signal.  UNIX only.
-
-        Return True if a signal handler was removed, False if not.
-        """
-        self._check_signal(sig)
-        try:
-            del self._signal_handlers[sig]
-        except KeyError:
-            return False
-
-        if sig == signal.SIGINT:
-            handler = signal.default_int_handler
-        else:
-            handler = signal.SIG_DFL
-
-        try:
-            signal.signal(sig, handler)
-        except OSError as exc:
-            if exc.errno == errno.EINVAL:
-                raise RuntimeError(f"sig {sig} cannot be caught")
-            else:
-                raise
-
-        if not self._signal_handlers:
-            try:
-                signal.set_wakeup_fd(-1)
-            except (ValueError, OSError) as exc:
-                logger.info("set_wakeup_fd(-1) failed: %s", exc)
-
-        return True
-
-    def _check_signal(self, sig):
-        """Internal helper to validate a signal.
-
-        Raise ValueError if the signal number is invalid or uncatchable.
-        Raise RuntimeError if there is a problem setting up the handler.
-        """
-        if not isinstance(sig, int):
-            raise TypeError(f"sig must be an int, not {sig!r}")
-
-        if not (1 <= sig < signal.NSIG):
-            raise ValueError(f"sig {sig} out of range(1, {signal.NSIG})")
-
-    def _make_read_pipe_transport(self, pipe, protocol, waiter=None, extra=None):
-        return _UnixReadPipeTransport(self, pipe, protocol, waiter, extra)
-
-    def _make_write_pipe_transport(self, pipe, protocol, waiter=None, extra=None):
-        return _UnixWritePipeTransport(self, pipe, protocol, waiter, extra)
-
-    async def _make_subprocess_transport(
-        self,
-        protocol,
-        args,
-        shell,
-        stdin,
-        stdout,
-        stderr,
-        bufsize,
-        extra=None,
-        **kwargs,
-    ):
-        with events.get_child_watcher() as watcher:
-            waiter = self.create_future()
-            transp = _UnixSubprocessTransport(
-                self,
-                protocol,
-                args,
-                shell,
-                stdin,
-                stdout,
-                stderr,
-                bufsize,
-                waiter=waiter,
-                extra=extra,
-                **kwargs,
-            )
-
-            watcher.add_child_handler(
-                transp.get_pid(), self._child_watcher_callback, transp
-            )
-            try:
-                await waiter
-            except Exception:
-                transp.close()
-                await transp._wait()
-                raise
-
-        return transp
-
-    def _child_watcher_callback(self, pid, returncode, transp):
-        self.call_soon_threadsafe(transp._process_exited, returncode)
-
-    async def create_unix_connection(
-        self,
-        protocol_factory,
-        path=None,
-        *,
-        ssl=None,
-        sock=None,
-        server_hostname=None,
-        ssl_handshake_timeout=None,
-    ):
-        assert server_hostname is None or isinstance(server_hostname, str)
-        if ssl:
-            if server_hostname is None:
-                raise ValueError("you have to pass server_hostname when using ssl")
-        else:
-            if server_hostname is not None:
-                raise ValueError("server_hostname is only meaningful with ssl")
-            if ssl_handshake_timeout is not None:
-                raise ValueError("ssl_handshake_timeout is only meaningful with ssl")
-
-        if path is not None:
-            if sock is not None:
-                raise ValueError("path and sock can not be specified at the same time")
-
-            path = os.fspath(path)
-            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM, 0)
-            try:
-                sock.setblocking(False)
-                await self.sock_connect(sock, path)
-            except:
-                sock.close()
-                raise
-
-        else:
-            if sock is None:
-                raise ValueError("no path and sock were specified")
-            if sock.family != socket.AF_UNIX or sock.type != socket.SOCK_STREAM:
-                raise ValueError(
-                    f"A UNIX Domain Stream Socket was expected, got {sock!r}"
-                )
-            sock.setblocking(False)
-
-        transport, protocol = await self._create_connection_transport(
-            sock,
-            protocol_factory,
-            ssl,
-            server_hostname,
-            ssl_handshake_timeout=ssl_handshake_timeout,
-        )
-        return transport, protocol
-
-    async def create_unix_server(
-        self,
-        protocol_factory,
-        path=None,
-        *,
-        sock=None,
-        backlog=100,
-        ssl=None,
-        ssl_handshake_timeout=None,
-        start_serving=True,
-    ):
-        if isinstance(ssl, bool):
-            raise TypeError("ssl argument must be an SSLContext or None")
-
-        if ssl_handshake_timeout is not None and not ssl:
-            raise ValueError("ssl_handshake_timeout is only meaningful with ssl")
-
-        if path is not None:
-            if sock is not None:
-                raise ValueError("path and sock can not be specified at the same time")
-
-            path = os.fspath(path)
-            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-
-            # Check for abstract socket. `str` and `bytes` paths are supported.
-            if path[0] not in (0, "\x00"):
-                try:
-                    if stat.S_ISSOCK(os.stat(path).st_mode):
-                        os.remove(path)
-                except FileNotFoundError:
-                    pass
-                except OSError as err:
-                    # Directory may have permissions only to create socket.
-                    logger.error(
-                        "Unable to check or remove stale UNIX socket " "%r: %r",
-                        path,
-                        err,
-                    )
-
-            try:
-                sock.bind(path)
-            except OSError as exc:
-                sock.close()
-                if exc.errno == errno.EADDRINUSE:
-                    # Let's improve the error message by adding
-                    # with what exact address it occurs.
-                    msg = f"Address {path!r} is already in use"
-                    raise OSError(errno.EADDRINUSE, msg) from None
-                else:
-                    raise
-            except:
-                sock.close()
-                raise
-        else:
-            if sock is None:
-                raise ValueError("path was not specified, and no sock specified")
-
-            if sock.family != socket.AF_UNIX or sock.type != socket.SOCK_STREAM:
-                raise ValueError(
-                    f"A UNIX Domain Stream Socket was expected, got {sock!r}"
-                )
-
-        sock.setblocking(False)
-        server = base_events.Server(
-            self, [sock], protocol_factory, ssl, backlog, ssl_handshake_timeout
-        )
-        if start_serving:
-            server._start_serving()
-            # Skip one loop iteration so that all 'loop.add_reader'
-            # go through.
-            await tasks.sleep(0, loop=self)
-
-        return server
-
-    async def _sock_sendfile_native(self, sock, file, offset, count):
-        try:
-            os.sendfile
-        except AttributeError as exc:
-            raise events.SendfileNotAvailableError("os.sendfile() is not available")
-        try:
-            fileno = file.fileno()
-        except (AttributeError, io.UnsupportedOperation) as err:
-            raise events.SendfileNotAvailableError("not a regular file")
-        try:
-            fsize = os.fstat(fileno).st_size
-        except OSError as err:
-            raise events.SendfileNotAvailableError("not a regular file")
-        blocksize = count if count else fsize
-        if not blocksize:
-            return 0  # empty file
-
-        fut = self.create_future()
-        self._sock_sendfile_native_impl(
-            fut, None, sock, fileno, offset, count, blocksize, 0
-        )
-        return await fut
-
-    def _sock_sendfile_native_impl(
-        self, fut, registered_fd, sock, fileno, offset, count, blocksize, total_sent
-    ):
-        fd = sock.fileno()
-        if registered_fd is not None:
-            # Remove the callback early.  It should be rare that the
-            # selector says the fd is ready but the call still returns
-            # EAGAIN, and I am willing to take a hit in that case in
-            # order to simplify the common case.
-            self.remove_writer(registered_fd)
-        if fut.cancelled():
-            self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-            return
-        if count:
-            blocksize = count - total_sent
-            if blocksize <= 0:
-                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-                fut.set_result(total_sent)
-                return
-
-        try:
-            sent = os.sendfile(fd, fileno, offset, blocksize)
-        except (BlockingIOError, InterruptedError):
-            if registered_fd is None:
-                self._sock_add_cancellation_callback(fut, sock)
-            self.add_writer(
-                fd,
-                self._sock_sendfile_native_impl,
-                fut,
-                fd,
-                sock,
-                fileno,
-                offset,
-                count,
-                blocksize,
-                total_sent,
-            )
-        except OSError as exc:
-            if (
-                registered_fd is not None
-                and exc.errno == errno.ENOTCONN
-                and type(exc) is not ConnectionError
-            ):
-                # If we have an ENOTCONN and this isn't a first call to
-                # sendfile(), i.e. the connection was closed in the middle
-                # of the operation, normalize the error to ConnectionError
-                # to make it consistent across all Posix systems.
-                new_exc = ConnectionError("socket is not connected", errno.ENOTCONN)
-                new_exc.__cause__ = exc
-                exc = new_exc
-            if total_sent == 0:
-                # We can get here for different reasons, the main
-                # one being 'file' is not a regular mmap(2)-like
-                # file, in which case we'll fall back on using
-                # plain send().
-                err = events.SendfileNotAvailableError("os.sendfile call failed")
-                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-                fut.set_exception(err)
-            else:
-                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-                fut.set_exception(exc)
-        except Exception as exc:
-            self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-            fut.set_exception(exc)
-        else:
-            if sent == 0:
-                # EOF
-                self._sock_sendfile_update_filepos(fileno, offset, total_sent)
-                fut.set_result(total_sent)
-            else:
-                offset += sent
-                total_sent += sent
-                if registered_fd is None:
-                    self._sock_add_cancellation_callback(fut, sock)
-                self.add_writer(
-                    fd,
-                    self._sock_sendfile_native_impl,
-                    fut,
-                    fd,
-                    sock,
-                    fileno,
-                    offset,
-                    count,
-                    blocksize,
-                    total_sent,
-                )
-
-    def _sock_sendfile_update_filepos(self, fileno, offset, total_sent):
-        if total_sent > 0:
-            os.lseek(fileno, offset, os.SEEK_SET)
-
-    def _sock_add_cancellation_callback(self, fut, sock):
-        def cb(fut):
-            if fut.cancelled():
-                fd = sock.fileno()
-                if fd != -1:
-                    self.remove_writer(fd)
-
-        fut.add_done_callback(cb)
-
-
-class _UnixReadPipeTransport(transports.ReadTransport):
-
-    max_size = 256 * 1024  # max bytes we read in one event loop iteration
-
-    def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
-        super().__init__(extra)
-        self._extra["pipe"] = pipe
-        self._loop = loop
-        self._pipe = pipe
-        self._fileno = pipe.fileno()
-        self._protocol = protocol
-        self._closing = False
-        self._paused = False
-
-        mode = os.fstat(self._fileno).st_mode
-        if not (stat.S_ISFIFO(mode) or stat.S_ISSOCK(mode) or stat.S_ISCHR(mode)):
-            self._pipe = None
-            self._fileno = None
-            self._protocol = None
-            raise ValueError("Pipe transport is for pipes/sockets only.")
-
-        os.set_blocking(self._fileno, False)
-
-        self._loop.call_soon(self._protocol.connection_made, self)
-        # only start reading when connection_made() has been called
-        self._loop.call_soon(self._loop._add_reader, self._fileno, self._read_ready)
-        if waiter is not None:
-            # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled, waiter, None)
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self._pipe is None:
-            info.append("closed")
-        elif self._closing:
-            info.append("closing")
-        info.append(f"fd={self._fileno}")
-        selector = getattr(self._loop, "_selector", None)
-        if self._pipe is not None and selector is not None:
-            polling = selector_events._test_selector_event(
-                selector, self._fileno, selectors.EVENT_READ
-            )
-            if polling:
-                info.append("polling")
-            else:
-                info.append("idle")
-        elif self._pipe is not None:
-            info.append("open")
-        else:
-            info.append("closed")
-        return "<{}>".format(" ".join(info))
-
-    def _read_ready(self):
-        try:
-            data = os.read(self._fileno, self.max_size)
-        except (BlockingIOError, InterruptedError):
-            pass
-        except OSError as exc:
-            self._fatal_error(exc, "Fatal read error on pipe transport")
-        else:
-            if data:
-                self._protocol.data_received(data)
-            else:
-                if self._loop.get_debug():
-                    logger.info("%r was closed by peer", self)
-                self._closing = True
-                self._loop._remove_reader(self._fileno)
-                self._loop.call_soon(self._protocol.eof_received)
-                self._loop.call_soon(self._call_connection_lost, None)
-
-    def pause_reading(self):
-        if self._closing or self._paused:
-            return
-        self._paused = True
-        self._loop._remove_reader(self._fileno)
-        if self._loop.get_debug():
-            logger.debug("%r pauses reading", self)
-
-    def resume_reading(self):
-        if self._closing or not self._paused:
-            return
-        self._paused = False
-        self._loop._add_reader(self._fileno, self._read_ready)
-        if self._loop.get_debug():
-            logger.debug("%r resumes reading", self)
-
-    def set_protocol(self, protocol):
-        self._protocol = protocol
-
-    def get_protocol(self):
-        return self._protocol
-
-    def is_closing(self):
-        return self._closing
-
-    def close(self):
-        if not self._closing:
-            self._close(None)
-
-    def __del__(self):
-        if self._pipe is not None:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self._pipe.close()
-
-    def _fatal_error(self, exc, message="Fatal error on pipe transport"):
-        # should be called by exception handler only
-        if isinstance(exc, OSError) and exc.errno == errno.EIO:
-            if self._loop.get_debug():
-                logger.debug("%r: %s", self, message, exc_info=True)
-        else:
-            self._loop.call_exception_handler(
-                {
-                    "message": message,
-                    "exception": exc,
-                    "transport": self,
-                    "protocol": self._protocol,
-                }
-            )
-        self._close(exc)
-
-    def _close(self, exc):
-        self._closing = True
-        self._loop._remove_reader(self._fileno)
-        self._loop.call_soon(self._call_connection_lost, exc)
-
-    def _call_connection_lost(self, exc):
-        try:
-            self._protocol.connection_lost(exc)
-        finally:
-            self._pipe.close()
-            self._pipe = None
-            self._protocol = None
-            self._loop = None
-
-
-class _UnixWritePipeTransport(transports._FlowControlMixin, transports.WriteTransport):
-    def __init__(self, loop, pipe, protocol, waiter=None, extra=None):
-        super().__init__(extra, loop)
-        self._extra["pipe"] = pipe
-        self._pipe = pipe
-        self._fileno = pipe.fileno()
-        self._protocol = protocol
-        self._buffer = bytearray()
-        self._conn_lost = 0
-        self._closing = False  # Set when close() or write_eof() called.
-
-        mode = os.fstat(self._fileno).st_mode
-        is_char = stat.S_ISCHR(mode)
-        is_fifo = stat.S_ISFIFO(mode)
-        is_socket = stat.S_ISSOCK(mode)
-        if not (is_char or is_fifo or is_socket):
-            self._pipe = None
-            self._fileno = None
-            self._protocol = None
-            raise ValueError(
-                "Pipe transport is only for " "pipes, sockets and character devices"
-            )
-
-        os.set_blocking(self._fileno, False)
-        self._loop.call_soon(self._protocol.connection_made, self)
-
-        # On AIX, the reader trick (to be notified when the read end of the
-        # socket is closed) only works for sockets. On other platforms it
-        # works for pipes and sockets. (Exception: OS X 10.4?  Issue #19294.)
-        if is_socket or (is_fifo and not sys.platform.startswith("aix")):
-            # only start reading when connection_made() has been called
-            self._loop.call_soon(self._loop._add_reader, self._fileno, self._read_ready)
-
-        if waiter is not None:
-            # only wake up the waiter when connection_made() has been called
-            self._loop.call_soon(futures._set_result_unless_cancelled, waiter, None)
-
-    def __repr__(self):
-        info = [self.__class__.__name__]
-        if self._pipe is None:
-            info.append("closed")
-        elif self._closing:
-            info.append("closing")
-        info.append(f"fd={self._fileno}")
-        selector = getattr(self._loop, "_selector", None)
-        if self._pipe is not None and selector is not None:
-            polling = selector_events._test_selector_event(
-                selector, self._fileno, selectors.EVENT_WRITE
-            )
-            if polling:
-                info.append("polling")
-            else:
-                info.append("idle")
-
-            bufsize = self.get_write_buffer_size()
-            info.append(f"bufsize={bufsize}")
-        elif self._pipe is not None:
-            info.append("open")
-        else:
-            info.append("closed")
-        return "<{}>".format(" ".join(info))
-
-    def get_write_buffer_size(self):
-        return len(self._buffer)
-
-    def _read_ready(self):
-        # Pipe was closed by peer.
-        if self._loop.get_debug():
-            logger.info("%r was closed by peer", self)
-        if self._buffer:
-            self._close(BrokenPipeError())
-        else:
-            self._close()
-
-    def write(self, data):
-        assert isinstance(data, (bytes, bytearray, memoryview)), repr(data)
-        if isinstance(data, bytearray):
-            data = memoryview(data)
-        if not data:
-            return
-
-        if self._conn_lost or self._closing:
-            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
-                logger.warning(
-                    "pipe closed by peer or " "os.write(pipe, data) raised exception."
-                )
-            self._conn_lost += 1
-            return
-
-        if not self._buffer:
-            # Attempt to send it right away first.
-            try:
-                n = os.write(self._fileno, data)
-            except (BlockingIOError, InterruptedError):
-                n = 0
-            except Exception as exc:
-                self._conn_lost += 1
-                self._fatal_error(exc, "Fatal write error on pipe transport")
-                return
-            if n == len(data):
-                return
-            elif n > 0:
-                data = memoryview(data)[n:]
-            self._loop._add_writer(self._fileno, self._write_ready)
-
-        self._buffer += data
-        self._maybe_pause_protocol()
-
-    def _write_ready(self):
-        assert self._buffer, "Data should not be empty"
-
-        try:
-            n = os.write(self._fileno, self._buffer)
-        except (BlockingIOError, InterruptedError):
-            pass
-        except Exception as exc:
-            self._buffer.clear()
-            self._conn_lost += 1
-            # Remove writer here, _fatal_error() doesn't it
-            # because _buffer is empty.
-            self._loop._remove_writer(self._fileno)
-            self._fatal_error(exc, "Fatal write error on pipe transport")
-        else:
-            if n == len(self._buffer):
-                self._buffer.clear()
-                self._loop._remove_writer(self._fileno)
-                self._maybe_resume_protocol()  # May append to buffer.
-                if self._closing:
-                    self._loop._remove_reader(self._fileno)
-                    self._call_connection_lost(None)
-                return
-            elif n > 0:
-                del self._buffer[:n]
-
-    def can_write_eof(self):
-        return True
-
-    def write_eof(self):
-        if self._closing:
-            return
-        assert self._pipe
-        self._closing = True
-        if not self._buffer:
-            self._loop._remove_reader(self._fileno)
-            self._loop.call_soon(self._call_connection_lost, None)
-
-    def set_protocol(self, protocol):
-        self._protocol = protocol
-
-    def get_protocol(self):
-        return self._protocol
-
-    def is_closing(self):
-        return self._closing
-
-    def close(self):
-        if self._pipe is not None and not self._closing:
-            # write_eof is all what we needed to close the write pipe
-            self.write_eof()
-
-    def __del__(self):
-        if self._pipe is not None:
-            warnings.warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
-            self._pipe.close()
-
-    def abort(self):
-        self._close(None)
-
-    def _fatal_error(self, exc, message="Fatal error on pipe transport"):
-        # should be called by exception handler only
-        if isinstance(exc, OSError):
-            if self._loop.get_debug():
-                logger.debug("%r: %s", self, message, exc_info=True)
-        else:
-            self._loop.call_exception_handler(
-                {
-                    "message": message,
-                    "exception": exc,
-                    "transport": self,
-                    "protocol": self._protocol,
-                }
-            )
-        self._close(exc)
-
-    def _close(self, exc=None):
-        self._closing = True
-        if self._buffer:
-            self._loop._remove_writer(self._fileno)
-        self._buffer.clear()
-        self._loop._remove_reader(self._fileno)
-        self._loop.call_soon(self._call_connection_lost, exc)
-
-    def _call_connection_lost(self, exc):
-        try:
-            self._protocol.connection_lost(exc)
-        finally:
-            self._pipe.close()
-            self._pipe = None
-            self._protocol = None
-            self._loop = None
-
-
-class _UnixSubprocessTransport(base_subprocess.BaseSubprocessTransport):
-    def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
-        stdin_w = None
-        if stdin == subprocess.PIPE:
-            # Use a socket pair for stdin, since not all platforms
-            # support selecting read events on the write end of a
-            # socket (which we use in order to detect closing of the
-            # other end).  Notably this is needed on AIX, and works
-            # just fine on other platforms.
-            stdin, stdin_w = socket.socketpair()
-        try:
-            self._proc = subprocess.Popen(
-                args,
-                shell=shell,
-                stdin=stdin,
-                stdout=stdout,
-                stderr=stderr,
-                universal_newlines=False,
-                bufsize=bufsize,
-                **kwargs,
-            )
-            if stdin_w is not None:
-                stdin.close()
-                self._proc.stdin = open(stdin_w.detach(), "wb", buffering=bufsize)
-                stdin_w = None
-        finally:
-            if stdin_w is not None:
-                stdin.close()
-                stdin_w.close()
-
-
-class AbstractChildWatcher:
-    """Abstract base class for monitoring child processes.
-
-    Objects derived from this class monitor a collection of subprocesses and
-    report their termination or interruption by a signal.
-
-    New callbacks are registered with .add_child_handler(). Starting a new
-    process must be done within a 'with' block to allow the watcher to suspend
-    its activity until the new process if fully registered (this is needed to
-    prevent a race condition in some implementations).
-
-    Example:
-        with watcher:
-            proc = subprocess.Popen("sleep 1")
-            watcher.add_child_handler(proc.pid, callback)
-
-    Notes:
-        Implementations of this class must be thread-safe.
-
-        Since child watcher objects may catch the SIGCHLD signal and call
-        waitpid(-1), there should be only one active object per process.
-    """
-
-    def add_child_handler(self, pid, callback, *args):
-        """Register a new child handler.
-
-        Arrange for callback(pid, returncode, *args) to be called when
-        process 'pid' terminates. Specifying another callback for the same
-        process replaces the previous handler.
-
-        Note: callback() must be thread-safe.
-        """
-        raise NotImplementedError()
-
-    def remove_child_handler(self, pid):
-        """Removes the handler for process 'pid'.
-
-        The function returns True if the handler was successfully removed,
-        False if there was nothing to remove."""
-
-        raise NotImplementedError()
-
-    def attach_loop(self, loop):
-        """Attach the watcher to an event loop.
-
-        If the watcher was previously attached to an event loop, then it is
-        first detached before attaching to the new loop.
-
-        Note: loop may be None.
-        """
-        raise NotImplementedError()
-
-    def close(self):
-        """Close the watcher.
-
-        This must be called to make sure that any underlying resource is freed.
-        """
-        raise NotImplementedError()
-
-    def __enter__(self):
-        """Enter the watcher's context and allow starting new processes
-
-        This function must return self"""
-        raise NotImplementedError()
-
-    def __exit__(self, a, b, c):
-        """Exit the watcher's context"""
-        raise NotImplementedError()
-
-
-class BaseChildWatcher(AbstractChildWatcher):
-    def __init__(self):
-        self._loop = None
-        self._callbacks = {}
-
-    def close(self):
-        self.attach_loop(None)
-
-    def _do_waitpid(self, expected_pid):
-        raise NotImplementedError()
-
-    def _do_waitpid_all(self):
-        raise NotImplementedError()
-
-    def attach_loop(self, loop):
-        assert loop is None or isinstance(loop, events.AbstractEventLoop)
-
-        if self._loop is not None and loop is None and self._callbacks:
-            warnings.warn(
-                "A loop is being detached "
-                "from a child watcher with pending handlers",
-                RuntimeWarning,
-            )
-
-        if self._loop is not None:
-            self._loop.remove_signal_handler(signal.SIGCHLD)
-
-        self._loop = loop
-        if loop is not None:
-            loop.add_signal_handler(signal.SIGCHLD, self._sig_chld)
-
-            # Prevent a race condition in case a child terminated
-            # during the switch.
-            self._do_waitpid_all()
-
-    def _sig_chld(self):
-        try:
-            self._do_waitpid_all()
-        except Exception as exc:
-            # self._loop should always be available here
-            # as '_sig_chld' is added as a signal handler
-            # in 'attach_loop'
-            self._loop.call_exception_handler(
-                {
-                    "message": "Unknown exception in SIGCHLD handler",
-                    "exception": exc,
-                }
-            )
-
-    def _compute_returncode(self, status):
-        if os.WIFSIGNALED(status):
-            # The child process died because of a signal.
-            return -os.WTERMSIG(status)
-        elif os.WIFEXITED(status):
-            # The child process exited (e.g sys.exit()).
-            return os.WEXITSTATUS(status)
-        else:
-            # The child exited, but we don't understand its status.
-            # This shouldn't happen, but if it does, let's just
-            # return that status; perhaps that helps debug it.
-            return status
-
-
-class SafeChildWatcher(BaseChildWatcher):
-    """'Safe' child watcher implementation.
-
-    This implementation avoids disrupting other code spawning processes by
-    polling explicitly each process in the SIGCHLD handler instead of calling
-    os.waitpid(-1).
-
-    This is a safe solution but it has a significant overhead when handling a
-    big number of children (O(n) each time SIGCHLD is raised)
-    """
-
-    def close(self):
-        self._callbacks.clear()
-        super().close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, a, b, c):
-        pass
-
-    def add_child_handler(self, pid, callback, *args):
-        if self._loop is None:
-            raise RuntimeError(
-                "Cannot add child handler, "
-                "the child watcher does not have a loop attached"
-            )
-
-        self._callbacks[pid] = (callback, args)
-
-        # Prevent a race condition in case the child is already terminated.
-        self._do_waitpid(pid)
-
-    def remove_child_handler(self, pid):
-        try:
-            del self._callbacks[pid]
-            return True
-        except KeyError:
-            return False
-
-    def _do_waitpid_all(self):
-
-        for pid in list(self._callbacks):
-            self._do_waitpid(pid)
-
-    def _do_waitpid(self, expected_pid):
-        assert expected_pid > 0
-
-        try:
-            pid, status = os.waitpid(expected_pid, os.WNOHANG)
-        except ChildProcessError:
-            # The child process is already reaped
-            # (may happen if waitpid() is called elsewhere).
-            pid = expected_pid
-            returncode = 255
-            logger.warning(
-                "Unknown child process pid %d, will report returncode 255", pid
-            )
-        else:
-            if pid == 0:
-                # The child process is still alive.
-                return
-
-            returncode = self._compute_returncode(status)
-            if self._loop.get_debug():
-                logger.debug(
-                    "process %s exited with returncode %s", expected_pid, returncode
-                )
-
-        try:
-            callback, args = self._callbacks.pop(pid)
-        except KeyError:  # pragma: no cover
-            # May happen if .remove_child_handler() is called
-            # after os.waitpid() returns.
-            if self._loop.get_debug():
-                logger.warning(
-                    "Child watcher got an unexpected pid: %r", pid, exc_info=True
-                )
-        else:
-            callback(pid, returncode, *args)
-
-
-class FastChildWatcher(BaseChildWatcher):
-    """'Fast' child watcher implementation.
-
-    This implementation reaps every terminated processes by calling
-    os.waitpid(-1) directly, possibly breaking other code spawning processes
-    and waiting for their termination.
-
-    There is no noticeable overhead when handling a big number of children
-    (O(1) each time a child terminates).
-    """
-
-    def __init__(self):
-        super().__init__()
-        self._lock = threading.Lock()
-        self._zombies = {}
-        self._forks = 0
-
-    def close(self):
-        self._callbacks.clear()
-        self._zombies.clear()
-        super().close()
-
-    def __enter__(self):
-        with self._lock:
-            self._forks += 1
-
-            return self
-
-    def __exit__(self, a, b, c):
-        with self._lock:
-            self._forks -= 1
-
-            if self._forks or not self._zombies:
-                return
-
-            collateral_victims = str(self._zombies)
-            self._zombies.clear()
-
-        logger.warning(
-            "Caught subprocesses termination from unknown pids: %s", collateral_victims
-        )
-
-    def add_child_handler(self, pid, callback, *args):
-        assert self._forks, "Must use the context manager"
-
-        if self._loop is None:
-            raise RuntimeError(
-                "Cannot add child handler, "
-                "the child watcher does not have a loop attached"
-            )
-
-        with self._lock:
-            try:
-                returncode = self._zombies.pop(pid)
-            except KeyError:
-                # The child is running.
-                self._callbacks[pid] = callback, args
-                return
-
-        # The child is dead already. We can fire the callback.
-        callback(pid, returncode, *args)
-
-    def remove_child_handler(self, pid):
-        try:
-            del self._callbacks[pid]
-            return True
-        except KeyError:
-            return False
-
-    def _do_waitpid_all(self):
-        # Because of signal coalescing, we must keep calling waitpid() as
-        # long as we're able to reap a child.
-        while True:
-            try:
-                pid, status = os.waitpid(-1, os.WNOHANG)
-            except ChildProcessError:
-                # No more child processes exist.
-                return
-            else:
-                if pid == 0:
-                    # A child process is still alive.
-                    return
-
-                returncode = self._compute_returncode(status)
-
-            with self._lock:
-                try:
-                    callback, args = self._callbacks.pop(pid)
-                except KeyError:
-                    # unknown child
-                    if self._forks:
-                        # It may not be registered yet.
-                        self._zombies[pid] = returncode
-                        if self._loop.get_debug():
-                            logger.debug(
-                                "unknown process %s exited " "with returncode %s",
-                                pid,
-                                returncode,
-                            )
-                        continue
-                    callback = None
-                else:
-                    if self._loop.get_debug():
-                        logger.debug(
-                            "process %s exited with returncode %s", pid, returncode
-                        )
-
-            if callback is None:
-                logger.warning(
-                    "Caught subprocess termination from unknown pid: " "%d -> %d",
-                    pid,
-                    returncode,
-                )
-            else:
-                callback(pid, returncode, *args)
-
-
-class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-    """UNIX event loop policy with a watcher for child processes."""
-
-    _loop_factory = _UnixSelectorEventLoop
-
-    def __init__(self):
-        super().__init__()
-        self._watcher = None
-
-    def _init_watcher(self):
-        with events._lock:
-            if self._watcher is None:  # pragma: no branch
-                self._watcher = SafeChildWatcher()
-                if isinstance(threading.current_thread(), threading._MainThread):
-                    self._watcher.attach_loop(self._local._loop)
-
-    def set_event_loop(self, loop):
-        """Set the event loop.
-
-        As a side effect, if a child watcher was set before, then calling
-        .set_event_loop() from the main thread will call .attach_loop(loop) on
-        the child watcher.
-        """
-
-        super().set_event_loop(loop)
-
-        if self._watcher is not None and isinstance(
-            threading.current_thread(), threading._MainThread
-        ):
-            self._watcher.attach_loop(loop)
-
-    def get_child_watcher(self):
-        """Get the watcher for child processes.
-
-        If not yet set, a SafeChildWatcher object is automatically created.
-        """
-        if self._watcher is None:
-            self._init_watcher()
-
-        return self._watcher
-
-    def set_child_watcher(self, watcher):
-        """Set the watcher for child processes."""
-
-        assert watcher is None or isinstance(watcher, AbstractChildWatcher)
-
-        if self._watcher is not None:
-            self._watcher.close()
-
-        self._watcher = watcher
-
-
-SelectorEventLoop = _UnixSelectorEventLoop
-DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/windows_events.py b/addon/globalPlugins/spellcheck/libs/asyncio/windows_events.py
deleted file mode 100644
index 5189e5f..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/windows_events.py
+++ /dev/null
@@ -1,898 +0,0 @@
-"""Selector and proactor event loops for Windows."""
-
-import _overlapped
-import _winapi
-import errno
-import math
-import msvcrt
-import socket
-import struct
-import time
-import weakref
-
-from . import events
-from . import base_subprocess
-from . import futures
-from . import proactor_events
-from . import selector_events
-from . import tasks
-from . import windows_utils
-from .log import logger
-
-
-__all__ = (
-    "SelectorEventLoop",
-    "ProactorEventLoop",
-    "IocpProactor",
-    "DefaultEventLoopPolicy",
-    "WindowsSelectorEventLoopPolicy",
-    "WindowsProactorEventLoopPolicy",
-)
-
-
-NULL = 0
-INFINITE = 0xFFFFFFFF
-ERROR_CONNECTION_REFUSED = 1225
-ERROR_CONNECTION_ABORTED = 1236
-
-# Initial delay in seconds for connect_pipe() before retrying to connect
-CONNECT_PIPE_INIT_DELAY = 0.001
-
-# Maximum delay in seconds for connect_pipe() before retrying to connect
-CONNECT_PIPE_MAX_DELAY = 0.100
-
-
-class _OverlappedFuture(futures.Future):
-    """Subclass of Future which represents an overlapped operation.
-
-    Cancelling it will immediately cancel the overlapped operation.
-    """
-
-    def __init__(self, ov, *, loop=None):
-        super().__init__(loop=loop)
-        if self._source_traceback:
-            del self._source_traceback[-1]
-        self._ov = ov
-
-    def _repr_info(self):
-        info = super()._repr_info()
-        if self._ov is not None:
-            state = "pending" if self._ov.pending else "completed"
-            info.insert(1, f"overlapped=<{state}, {self._ov.address:#x}>")
-        return info
-
-    def _cancel_overlapped(self):
-        if self._ov is None:
-            return
-        try:
-            self._ov.cancel()
-        except OSError as exc:
-            context = {
-                "message": "Cancelling an overlapped future failed",
-                "exception": exc,
-                "future": self,
-            }
-            if self._source_traceback:
-                context["source_traceback"] = self._source_traceback
-            self._loop.call_exception_handler(context)
-        self._ov = None
-
-    def cancel(self):
-        self._cancel_overlapped()
-        return super().cancel()
-
-    def set_exception(self, exception):
-        super().set_exception(exception)
-        self._cancel_overlapped()
-
-    def set_result(self, result):
-        super().set_result(result)
-        self._ov = None
-
-
-class _BaseWaitHandleFuture(futures.Future):
-    """Subclass of Future which represents a wait handle."""
-
-    def __init__(self, ov, handle, wait_handle, *, loop=None):
-        super().__init__(loop=loop)
-        if self._source_traceback:
-            del self._source_traceback[-1]
-        # Keep a reference to the Overlapped object to keep it alive until the
-        # wait is unregistered
-        self._ov = ov
-        self._handle = handle
-        self._wait_handle = wait_handle
-
-        # Should we call UnregisterWaitEx() if the wait completes
-        # or is cancelled?
-        self._registered = True
-
-    def _poll(self):
-        # non-blocking wait: use a timeout of 0 millisecond
-        return _winapi.WaitForSingleObject(self._handle, 0) == _winapi.WAIT_OBJECT_0
-
-    def _repr_info(self):
-        info = super()._repr_info()
-        info.append(f"handle={self._handle:#x}")
-        if self._handle is not None:
-            state = "signaled" if self._poll() else "waiting"
-            info.append(state)
-        if self._wait_handle is not None:
-            info.append(f"wait_handle={self._wait_handle:#x}")
-        return info
-
-    def _unregister_wait_cb(self, fut):
-        # The wait was unregistered: it's not safe to destroy the Overlapped
-        # object
-        self._ov = None
-
-    def _unregister_wait(self):
-        if not self._registered:
-            return
-        self._registered = False
-
-        wait_handle = self._wait_handle
-        self._wait_handle = None
-        try:
-            _overlapped.UnregisterWait(wait_handle)
-        except OSError as exc:
-            if exc.winerror != _overlapped.ERROR_IO_PENDING:
-                context = {
-                    "message": "Failed to unregister the wait handle",
-                    "exception": exc,
-                    "future": self,
-                }
-                if self._source_traceback:
-                    context["source_traceback"] = self._source_traceback
-                self._loop.call_exception_handler(context)
-                return
-            # ERROR_IO_PENDING means that the unregister is pending
-
-        self._unregister_wait_cb(None)
-
-    def cancel(self):
-        self._unregister_wait()
-        return super().cancel()
-
-    def set_exception(self, exception):
-        self._unregister_wait()
-        super().set_exception(exception)
-
-    def set_result(self, result):
-        self._unregister_wait()
-        super().set_result(result)
-
-
-class _WaitCancelFuture(_BaseWaitHandleFuture):
-    """Subclass of Future which represents a wait for the cancellation of a
-    _WaitHandleFuture using an event.
-    """
-
-    def __init__(self, ov, event, wait_handle, *, loop=None):
-        super().__init__(ov, event, wait_handle, loop=loop)
-
-        self._done_callback = None
-
-    def cancel(self):
-        raise RuntimeError("_WaitCancelFuture must not be cancelled")
-
-    def set_result(self, result):
-        super().set_result(result)
-        if self._done_callback is not None:
-            self._done_callback(self)
-
-    def set_exception(self, exception):
-        super().set_exception(exception)
-        if self._done_callback is not None:
-            self._done_callback(self)
-
-
-class _WaitHandleFuture(_BaseWaitHandleFuture):
-    def __init__(self, ov, handle, wait_handle, proactor, *, loop=None):
-        super().__init__(ov, handle, wait_handle, loop=loop)
-        self._proactor = proactor
-        self._unregister_proactor = True
-        self._event = _overlapped.CreateEvent(None, True, False, None)
-        self._event_fut = None
-
-    def _unregister_wait_cb(self, fut):
-        if self._event is not None:
-            _winapi.CloseHandle(self._event)
-            self._event = None
-            self._event_fut = None
-
-        # If the wait was cancelled, the wait may never be signalled, so
-        # it's required to unregister it. Otherwise, IocpProactor.close() will
-        # wait forever for an event which will never come.
-        #
-        # If the IocpProactor already received the event, it's safe to call
-        # _unregister() because we kept a reference to the Overlapped object
-        # which is used as a unique key.
-        self._proactor._unregister(self._ov)
-        self._proactor = None
-
-        super()._unregister_wait_cb(fut)
-
-    def _unregister_wait(self):
-        if not self._registered:
-            return
-        self._registered = False
-
-        wait_handle = self._wait_handle
-        self._wait_handle = None
-        try:
-            _overlapped.UnregisterWaitEx(wait_handle, self._event)
-        except OSError as exc:
-            if exc.winerror != _overlapped.ERROR_IO_PENDING:
-                context = {
-                    "message": "Failed to unregister the wait handle",
-                    "exception": exc,
-                    "future": self,
-                }
-                if self._source_traceback:
-                    context["source_traceback"] = self._source_traceback
-                self._loop.call_exception_handler(context)
-                return
-            # ERROR_IO_PENDING is not an error, the wait was unregistered
-
-        self._event_fut = self._proactor._wait_cancel(
-            self._event, self._unregister_wait_cb
-        )
-
-
-class PipeServer(object):
-    """Class representing a pipe server.
-
-    This is much like a bound, listening socket.
-    """
-
-    def __init__(self, address):
-        self._address = address
-        self._free_instances = weakref.WeakSet()
-        # initialize the pipe attribute before calling _server_pipe_handle()
-        # because this function can raise an exception and the destructor calls
-        # the close() method
-        self._pipe = None
-        self._accept_pipe_future = None
-        self._pipe = self._server_pipe_handle(True)
-
-    def _get_unconnected_pipe(self):
-        # Create new instance and return previous one.  This ensures
-        # that (until the server is closed) there is always at least
-        # one pipe handle for address.  Therefore if a client attempt
-        # to connect it will not fail with FileNotFoundError.
-        tmp, self._pipe = self._pipe, self._server_pipe_handle(False)
-        return tmp
-
-    def _server_pipe_handle(self, first):
-        # Return a wrapper for a new pipe handle.
-        if self.closed():
-            return None
-        flags = _winapi.PIPE_ACCESS_DUPLEX | _winapi.FILE_FLAG_OVERLAPPED
-        if first:
-            flags |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
-        h = _winapi.CreateNamedPipe(
-            self._address,
-            flags,
-            _winapi.PIPE_TYPE_MESSAGE
-            | _winapi.PIPE_READMODE_MESSAGE
-            | _winapi.PIPE_WAIT,
-            _winapi.PIPE_UNLIMITED_INSTANCES,
-            windows_utils.BUFSIZE,
-            windows_utils.BUFSIZE,
-            _winapi.NMPWAIT_WAIT_FOREVER,
-            _winapi.NULL,
-        )
-        pipe = windows_utils.PipeHandle(h)
-        self._free_instances.add(pipe)
-        return pipe
-
-    def closed(self):
-        return self._address is None
-
-    def close(self):
-        if self._accept_pipe_future is not None:
-            self._accept_pipe_future.cancel()
-            self._accept_pipe_future = None
-        # Close all instances which have not been connected to by a client.
-        if self._address is not None:
-            for pipe in self._free_instances:
-                pipe.close()
-            self._pipe = None
-            self._address = None
-            self._free_instances.clear()
-
-    __del__ = close
-
-
-class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop):
-    """Windows version of selector event loop."""
-
-
-class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
-    """Windows version of proactor event loop using IOCP."""
-
-    def __init__(self, proactor=None):
-        if proactor is None:
-            proactor = IocpProactor()
-        super().__init__(proactor)
-
-    async def create_pipe_connection(self, protocol_factory, address):
-        f = self._proactor.connect_pipe(address)
-        pipe = await f
-        protocol = protocol_factory()
-        trans = self._make_duplex_pipe_transport(
-            pipe, protocol, extra={"addr": address}
-        )
-        return trans, protocol
-
-    async def start_serving_pipe(self, protocol_factory, address):
-        server = PipeServer(address)
-
-        def loop_accept_pipe(f=None):
-            pipe = None
-            try:
-                if f:
-                    pipe = f.result()
-                    server._free_instances.discard(pipe)
-
-                    if server.closed():
-                        # A client connected before the server was closed:
-                        # drop the client (close the pipe) and exit
-                        pipe.close()
-                        return
-
-                    protocol = protocol_factory()
-                    self._make_duplex_pipe_transport(
-                        pipe, protocol, extra={"addr": address}
-                    )
-
-                pipe = server._get_unconnected_pipe()
-                if pipe is None:
-                    return
-
-                f = self._proactor.accept_pipe(pipe)
-            except OSError as exc:
-                if pipe and pipe.fileno() != -1:
-                    self.call_exception_handler(
-                        {
-                            "message": "Pipe accept failed",
-                            "exception": exc,
-                            "pipe": pipe,
-                        }
-                    )
-                    pipe.close()
-                elif self._debug:
-                    logger.warning("Accept pipe failed on pipe %r", pipe, exc_info=True)
-            except futures.CancelledError:
-                if pipe:
-                    pipe.close()
-            else:
-                server._accept_pipe_future = f
-                f.add_done_callback(loop_accept_pipe)
-
-        self.call_soon(loop_accept_pipe)
-        return [server]
-
-    async def _make_subprocess_transport(
-        self,
-        protocol,
-        args,
-        shell,
-        stdin,
-        stdout,
-        stderr,
-        bufsize,
-        extra=None,
-        **kwargs,
-    ):
-        waiter = self.create_future()
-        transp = _WindowsSubprocessTransport(
-            self,
-            protocol,
-            args,
-            shell,
-            stdin,
-            stdout,
-            stderr,
-            bufsize,
-            waiter=waiter,
-            extra=extra,
-            **kwargs,
-        )
-        try:
-            await waiter
-        except Exception:
-            transp.close()
-            await transp._wait()
-            raise
-
-        return transp
-
-
-class IocpProactor:
-    """Proactor implementation using IOCP."""
-
-    def __init__(self, concurrency=0xFFFFFFFF):
-        self._loop = None
-        self._results = []
-        self._iocp = _overlapped.CreateIoCompletionPort(
-            _overlapped.INVALID_HANDLE_VALUE, NULL, 0, concurrency
-        )
-        self._cache = {}
-        self._registered = weakref.WeakSet()
-        self._unregistered = []
-        self._stopped_serving = weakref.WeakSet()
-
-    def _check_closed(self):
-        if self._iocp is None:
-            raise RuntimeError("IocpProactor is closed")
-
-    def __repr__(self):
-        info = ["overlapped#=%s" % len(self._cache), "result#=%s" % len(self._results)]
-        if self._iocp is None:
-            info.append("closed")
-        return "<%s %s>" % (self.__class__.__name__, " ".join(info))
-
-    def set_loop(self, loop):
-        self._loop = loop
-
-    def select(self, timeout=None):
-        if not self._results:
-            self._poll(timeout)
-        tmp = self._results
-        self._results = []
-        return tmp
-
-    def _result(self, value):
-        fut = self._loop.create_future()
-        fut.set_result(value)
-        return fut
-
-    def recv(self, conn, nbytes, flags=0):
-        self._register_with_iocp(conn)
-        ov = _overlapped.Overlapped(NULL)
-        try:
-            if isinstance(conn, socket.socket):
-                ov.WSARecv(conn.fileno(), nbytes, flags)
-            else:
-                ov.ReadFile(conn.fileno(), nbytes)
-        except BrokenPipeError:
-            return self._result(b"")
-
-        def finish_recv(trans, key, ov):
-            try:
-                return ov.getresult()
-            except OSError as exc:
-                if exc.winerror in (
-                    _overlapped.ERROR_NETNAME_DELETED,
-                    _overlapped.ERROR_OPERATION_ABORTED,
-                ):
-                    raise ConnectionResetError(*exc.args)
-                else:
-                    raise
-
-        return self._register(ov, conn, finish_recv)
-
-    def recv_into(self, conn, buf, flags=0):
-        self._register_with_iocp(conn)
-        ov = _overlapped.Overlapped(NULL)
-        try:
-            if isinstance(conn, socket.socket):
-                ov.WSARecvInto(conn.fileno(), buf, flags)
-            else:
-                ov.ReadFileInto(conn.fileno(), buf)
-        except BrokenPipeError:
-            return self._result(b"")
-
-        def finish_recv(trans, key, ov):
-            try:
-                return ov.getresult()
-            except OSError as exc:
-                if exc.winerror in (
-                    _overlapped.ERROR_NETNAME_DELETED,
-                    _overlapped.ERROR_OPERATION_ABORTED,
-                ):
-                    raise ConnectionResetError(*exc.args)
-                else:
-                    raise
-
-        return self._register(ov, conn, finish_recv)
-
-    def send(self, conn, buf, flags=0):
-        self._register_with_iocp(conn)
-        ov = _overlapped.Overlapped(NULL)
-        if isinstance(conn, socket.socket):
-            ov.WSASend(conn.fileno(), buf, flags)
-        else:
-            ov.WriteFile(conn.fileno(), buf)
-
-        def finish_send(trans, key, ov):
-            try:
-                return ov.getresult()
-            except OSError as exc:
-                if exc.winerror in (
-                    _overlapped.ERROR_NETNAME_DELETED,
-                    _overlapped.ERROR_OPERATION_ABORTED,
-                ):
-                    raise ConnectionResetError(*exc.args)
-                else:
-                    raise
-
-        return self._register(ov, conn, finish_send)
-
-    def accept(self, listener):
-        self._register_with_iocp(listener)
-        conn = self._get_accept_socket(listener.family)
-        ov = _overlapped.Overlapped(NULL)
-        ov.AcceptEx(listener.fileno(), conn.fileno())
-
-        def finish_accept(trans, key, ov):
-            ov.getresult()
-            # Use SO_UPDATE_ACCEPT_CONTEXT so getsockname() etc work.
-            buf = struct.pack("@P", listener.fileno())
-            conn.setsockopt(
-                socket.SOL_SOCKET, _overlapped.SO_UPDATE_ACCEPT_CONTEXT, buf
-            )
-            conn.settimeout(listener.gettimeout())
-            return conn, conn.getpeername()
-
-        async def accept_coro(future, conn):
-            # Coroutine closing the accept socket if the future is cancelled
-            try:
-                await future
-            except futures.CancelledError:
-                conn.close()
-                raise
-
-        future = self._register(ov, listener, finish_accept)
-        coro = accept_coro(future, conn)
-        tasks.ensure_future(coro, loop=self._loop)
-        return future
-
-    def connect(self, conn, address):
-        self._register_with_iocp(conn)
-        # The socket needs to be locally bound before we call ConnectEx().
-        try:
-            _overlapped.BindLocal(conn.fileno(), conn.family)
-        except OSError as e:
-            if e.winerror != errno.WSAEINVAL:
-                raise
-            # Probably already locally bound; check using getsockname().
-            if conn.getsockname()[1] == 0:
-                raise
-        ov = _overlapped.Overlapped(NULL)
-        ov.ConnectEx(conn.fileno(), address)
-
-        def finish_connect(trans, key, ov):
-            ov.getresult()
-            # Use SO_UPDATE_CONNECT_CONTEXT so getsockname() etc work.
-            conn.setsockopt(socket.SOL_SOCKET, _overlapped.SO_UPDATE_CONNECT_CONTEXT, 0)
-            return conn
-
-        return self._register(ov, conn, finish_connect)
-
-    def sendfile(self, sock, file, offset, count):
-        self._register_with_iocp(sock)
-        ov = _overlapped.Overlapped(NULL)
-        offset_low = offset & 0xFFFF_FFFF
-        offset_high = (offset >> 32) & 0xFFFF_FFFF
-        ov.TransmitFile(
-            sock.fileno(),
-            msvcrt.get_osfhandle(file.fileno()),
-            offset_low,
-            offset_high,
-            count,
-            0,
-            0,
-        )
-
-        def finish_sendfile(trans, key, ov):
-            try:
-                return ov.getresult()
-            except OSError as exc:
-                if exc.winerror in (
-                    _overlapped.ERROR_NETNAME_DELETED,
-                    _overlapped.ERROR_OPERATION_ABORTED,
-                ):
-                    raise ConnectionResetError(*exc.args)
-                else:
-                    raise
-
-        return self._register(ov, sock, finish_sendfile)
-
-    def accept_pipe(self, pipe):
-        self._register_with_iocp(pipe)
-        ov = _overlapped.Overlapped(NULL)
-        connected = ov.ConnectNamedPipe(pipe.fileno())
-
-        if connected:
-            # ConnectNamePipe() failed with ERROR_PIPE_CONNECTED which means
-            # that the pipe is connected. There is no need to wait for the
-            # completion of the connection.
-            return self._result(pipe)
-
-        def finish_accept_pipe(trans, key, ov):
-            ov.getresult()
-            return pipe
-
-        return self._register(ov, pipe, finish_accept_pipe)
-
-    async def connect_pipe(self, address):
-        delay = CONNECT_PIPE_INIT_DELAY
-        while True:
-            # Unfortunately there is no way to do an overlapped connect to
-            # a pipe.  Call CreateFile() in a loop until it doesn't fail with
-            # ERROR_PIPE_BUSY.
-            try:
-                handle = _overlapped.ConnectPipe(address)
-                break
-            except OSError as exc:
-                if exc.winerror != _overlapped.ERROR_PIPE_BUSY:
-                    raise
-
-            # ConnectPipe() failed with ERROR_PIPE_BUSY: retry later
-            delay = min(delay * 2, CONNECT_PIPE_MAX_DELAY)
-            await tasks.sleep(delay, loop=self._loop)
-
-        return windows_utils.PipeHandle(handle)
-
-    def wait_for_handle(self, handle, timeout=None):
-        """Wait for a handle.
-
-        Return a Future object. The result of the future is True if the wait
-        completed, or False if the wait did not complete (on timeout).
-        """
-        return self._wait_for_handle(handle, timeout, False)
-
-    def _wait_cancel(self, event, done_callback):
-        fut = self._wait_for_handle(event, None, True)
-        # add_done_callback() cannot be used because the wait may only complete
-        # in IocpProactor.close(), while the event loop is not running.
-        fut._done_callback = done_callback
-        return fut
-
-    def _wait_for_handle(self, handle, timeout, _is_cancel):
-        self._check_closed()
-
-        if timeout is None:
-            ms = _winapi.INFINITE
-        else:
-            # RegisterWaitForSingleObject() has a resolution of 1 millisecond,
-            # round away from zero to wait *at least* timeout seconds.
-            ms = math.ceil(timeout * 1e3)
-
-        # We only create ov so we can use ov.address as a key for the cache.
-        ov = _overlapped.Overlapped(NULL)
-        wait_handle = _overlapped.RegisterWaitWithQueue(
-            handle, self._iocp, ov.address, ms
-        )
-        if _is_cancel:
-            f = _WaitCancelFuture(ov, handle, wait_handle, loop=self._loop)
-        else:
-            f = _WaitHandleFuture(ov, handle, wait_handle, self, loop=self._loop)
-        if f._source_traceback:
-            del f._source_traceback[-1]
-
-        def finish_wait_for_handle(trans, key, ov):
-            # Note that this second wait means that we should only use
-            # this with handles types where a successful wait has no
-            # effect.  So events or processes are all right, but locks
-            # or semaphores are not.  Also note if the handle is
-            # signalled and then quickly reset, then we may return
-            # False even though we have not timed out.
-            return f._poll()
-
-        self._cache[ov.address] = (f, ov, 0, finish_wait_for_handle)
-        return f
-
-    def _register_with_iocp(self, obj):
-        # To get notifications of finished ops on this objects sent to the
-        # completion port, were must register the handle.
-        if obj not in self._registered:
-            self._registered.add(obj)
-            _overlapped.CreateIoCompletionPort(obj.fileno(), self._iocp, 0, 0)
-            # XXX We could also use SetFileCompletionNotificationModes()
-            # to avoid sending notifications to completion port of ops
-            # that succeed immediately.
-
-    def _register(self, ov, obj, callback):
-        self._check_closed()
-
-        # Return a future which will be set with the result of the
-        # operation when it completes.  The future's value is actually
-        # the value returned by callback().
-        f = _OverlappedFuture(ov, loop=self._loop)
-        if f._source_traceback:
-            del f._source_traceback[-1]
-        if not ov.pending:
-            # The operation has completed, so no need to postpone the
-            # work.  We cannot take this short cut if we need the
-            # NumberOfBytes, CompletionKey values returned by
-            # PostQueuedCompletionStatus().
-            try:
-                value = callback(None, None, ov)
-            except OSError as e:
-                f.set_exception(e)
-            else:
-                f.set_result(value)
-            # Even if GetOverlappedResult() was called, we have to wait for the
-            # notification of the completion in GetQueuedCompletionStatus().
-            # Register the overlapped operation to keep a reference to the
-            # OVERLAPPED object, otherwise the memory is freed and Windows may
-            # read uninitialized memory.
-
-        # Register the overlapped operation for later.  Note that
-        # we only store obj to prevent it from being garbage
-        # collected too early.
-        self._cache[ov.address] = (f, ov, obj, callback)
-        return f
-
-    def _unregister(self, ov):
-        """Unregister an overlapped object.
-
-        Call this method when its future has been cancelled. The event can
-        already be signalled (pending in the proactor event queue). It is also
-        safe if the event is never signalled (because it was cancelled).
-        """
-        self._check_closed()
-        self._unregistered.append(ov)
-
-    def _get_accept_socket(self, family):
-        s = socket.socket(family)
-        s.settimeout(0)
-        return s
-
-    def _poll(self, timeout=None):
-        if timeout is None:
-            ms = INFINITE
-        elif timeout < 0:
-            raise ValueError("negative timeout")
-        else:
-            # GetQueuedCompletionStatus() has a resolution of 1 millisecond,
-            # round away from zero to wait *at least* timeout seconds.
-            ms = math.ceil(timeout * 1e3)
-            if ms >= INFINITE:
-                raise ValueError("timeout too big")
-
-        while True:
-            status = _overlapped.GetQueuedCompletionStatus(self._iocp, ms)
-            if status is None:
-                break
-            ms = 0
-
-            err, transferred, key, address = status
-            try:
-                f, ov, obj, callback = self._cache.pop(address)
-            except KeyError:
-                if self._loop.get_debug():
-                    self._loop.call_exception_handler(
-                        {
-                            "message": (
-                                "GetQueuedCompletionStatus() returned an "
-                                "unexpected event"
-                            ),
-                            "status": (
-                                "err=%s transferred=%s key=%#x address=%#x"
-                                % (err, transferred, key, address)
-                            ),
-                        }
-                    )
-
-                # key is either zero, or it is used to return a pipe
-                # handle which should be closed to avoid a leak.
-                if key not in (0, _overlapped.INVALID_HANDLE_VALUE):
-                    _winapi.CloseHandle(key)
-                continue
-
-            if obj in self._stopped_serving:
-                f.cancel()
-            # Don't call the callback if _register() already read the result or
-            # if the overlapped has been cancelled
-            elif not f.done():
-                try:
-                    value = callback(transferred, key, ov)
-                except OSError as e:
-                    f.set_exception(e)
-                    self._results.append(f)
-                else:
-                    f.set_result(value)
-                    self._results.append(f)
-
-        # Remove unregistered futures
-        for ov in self._unregistered:
-            self._cache.pop(ov.address, None)
-        self._unregistered.clear()
-
-    def _stop_serving(self, obj):
-        # obj is a socket or pipe handle.  It will be closed in
-        # BaseProactorEventLoop._stop_serving() which will make any
-        # pending operations fail quickly.
-        self._stopped_serving.add(obj)
-
-    def close(self):
-        if self._iocp is None:
-            # already closed
-            return
-
-        # Cancel remaining registered operations.
-        for address, (fut, ov, obj, callback) in list(self._cache.items()):
-            if fut.cancelled():
-                # Nothing to do with cancelled futures
-                pass
-            elif isinstance(fut, _WaitCancelFuture):
-                # _WaitCancelFuture must not be cancelled
-                pass
-            else:
-                try:
-                    fut.cancel()
-                except OSError as exc:
-                    if self._loop is not None:
-                        context = {
-                            "message": "Cancelling a future failed",
-                            "exception": exc,
-                            "future": fut,
-                        }
-                        if fut._source_traceback:
-                            context["source_traceback"] = fut._source_traceback
-                        self._loop.call_exception_handler(context)
-
-        # Wait until all cancelled overlapped complete: don't exit with running
-        # overlapped to prevent a crash. Display progress every second if the
-        # loop is still running.
-        msg_update = 1.0
-        start_time = time.monotonic()
-        next_msg = start_time + msg_update
-        while self._cache:
-            if next_msg <= time.monotonic():
-                logger.debug(
-                    "%r is running after closing for %.1f seconds",
-                    self,
-                    time.monotonic() - start_time,
-                )
-                next_msg = time.monotonic() + msg_update
-
-            # handle a few events, or timeout
-            self._poll(msg_update)
-
-        self._results = []
-
-        _winapi.CloseHandle(self._iocp)
-        self._iocp = None
-
-    def __del__(self):
-        self.close()
-
-
-class _WindowsSubprocessTransport(base_subprocess.BaseSubprocessTransport):
-    def _start(self, args, shell, stdin, stdout, stderr, bufsize, **kwargs):
-        self._proc = windows_utils.Popen(
-            args,
-            shell=shell,
-            stdin=stdin,
-            stdout=stdout,
-            stderr=stderr,
-            bufsize=bufsize,
-            **kwargs,
-        )
-
-        def callback(f):
-            returncode = self._proc.poll()
-            self._process_exited(returncode)
-
-        f = self._loop._proactor.wait_for_handle(int(self._proc._handle))
-        f.add_done_callback(callback)
-
-
-SelectorEventLoop = _WindowsSelectorEventLoop
-
-
-class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-    _loop_factory = SelectorEventLoop
-
-
-class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
-    _loop_factory = ProactorEventLoop
-
-
-DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy
diff --git a/addon/globalPlugins/spellcheck/libs/asyncio/windows_utils.py b/addon/globalPlugins/spellcheck/libs/asyncio/windows_utils.py
deleted file mode 100644
index 75eb4cd..0000000
--- a/addon/globalPlugins/spellcheck/libs/asyncio/windows_utils.py
+++ /dev/null
@@ -1,191 +0,0 @@
-"""Various Windows specific bits and pieces."""
-
-import sys
-
-if sys.platform != "win32":  # pragma: no cover
-    raise ImportError("win32 only")
-
-import _winapi
-import itertools
-import msvcrt
-import os
-import subprocess
-import tempfile
-import warnings
-
-
-__all__ = "pipe", "Popen", "PIPE", "PipeHandle"
-
-
-# Constants/globals
-
-
-BUFSIZE = 8192
-PIPE = subprocess.PIPE
-STDOUT = subprocess.STDOUT
-_mmap_counter = itertools.count()
-
-
-# Replacement for os.pipe() using handles instead of fds
-
-
-def pipe(*, duplex=False, overlapped=(True, True), bufsize=BUFSIZE):
-    """Like os.pipe() but with overlapped support and using handles not fds."""
-    address = tempfile.mktemp(
-        prefix=r"\\.\pipe\python-pipe-{:d}-{:d}-".format(
-            os.getpid(), next(_mmap_counter)
-        )
-    )
-
-    if duplex:
-        openmode = _winapi.PIPE_ACCESS_DUPLEX
-        access = _winapi.GENERIC_READ | _winapi.GENERIC_WRITE
-        obsize, ibsize = bufsize, bufsize
-    else:
-        openmode = _winapi.PIPE_ACCESS_INBOUND
-        access = _winapi.GENERIC_WRITE
-        obsize, ibsize = 0, bufsize
-
-    openmode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
-
-    if overlapped[0]:
-        openmode |= _winapi.FILE_FLAG_OVERLAPPED
-
-    if overlapped[1]:
-        flags_and_attribs = _winapi.FILE_FLAG_OVERLAPPED
-    else:
-        flags_and_attribs = 0
-
-    h1 = h2 = None
-    try:
-        h1 = _winapi.CreateNamedPipe(
-            address,
-            openmode,
-            _winapi.PIPE_WAIT,
-            1,
-            obsize,
-            ibsize,
-            _winapi.NMPWAIT_WAIT_FOREVER,
-            _winapi.NULL,
-        )
-
-        h2 = _winapi.CreateFile(
-            address,
-            access,
-            0,
-            _winapi.NULL,
-            _winapi.OPEN_EXISTING,
-            flags_and_attribs,
-            _winapi.NULL,
-        )
-
-        ov = _winapi.ConnectNamedPipe(h1, overlapped=True)
-        ov.GetOverlappedResult(True)
-        return h1, h2
-    except:
-        if h1 is not None:
-            _winapi.CloseHandle(h1)
-        if h2 is not None:
-            _winapi.CloseHandle(h2)
-        raise
-
-
-# Wrapper for a pipe handle
-
-
-class PipeHandle:
-    """Wrapper for an overlapped pipe handle which is vaguely file-object like.
-
-    The IOCP event loop can use these instead of socket objects.
-    """
-
-    def __init__(self, handle):
-        self._handle = handle
-
-    def __repr__(self):
-        if self._handle is not None:
-            handle = f"handle={self._handle!r}"
-        else:
-            handle = "closed"
-        return f"<{self.__class__.__name__} {handle}>"
-
-    @property
-    def handle(self):
-        return self._handle
-
-    def fileno(self):
-        if self._handle is None:
-            raise ValueError("I/O operation on closed pipe")
-        return self._handle
-
-    def close(self, *, CloseHandle=_winapi.CloseHandle):
-        if self._handle is not None:
-            CloseHandle(self._handle)
-            self._handle = None
-
-    def __del__(self):
-        if self._handle is not None:
-            warnings.warn(f"unclosed {self!r}", ResourceWarning, source=self)
-            self.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, t, v, tb):
-        self.close()
-
-
-# Replacement for subprocess.Popen using overlapped pipe handles
-
-
-class Popen(subprocess.Popen):
-    """Replacement for subprocess.Popen using overlapped pipe handles.
-
-    The stdin, stdout, stderr are None or instances of PipeHandle.
-    """
-
-    def __init__(self, args, stdin=None, stdout=None, stderr=None, **kwds):
-        assert not kwds.get("universal_newlines")
-        assert kwds.get("bufsize", 0) == 0
-        stdin_rfd = stdout_wfd = stderr_wfd = None
-        stdin_wh = stdout_rh = stderr_rh = None
-        if stdin == PIPE:
-            stdin_rh, stdin_wh = pipe(overlapped=(False, True), duplex=True)
-            stdin_rfd = msvcrt.open_osfhandle(stdin_rh, os.O_RDONLY)
-        else:
-            stdin_rfd = stdin
-        if stdout == PIPE:
-            stdout_rh, stdout_wh = pipe(overlapped=(True, False))
-            stdout_wfd = msvcrt.open_osfhandle(stdout_wh, 0)
-        else:
-            stdout_wfd = stdout
-        if stderr == PIPE:
-            stderr_rh, stderr_wh = pipe(overlapped=(True, False))
-            stderr_wfd = msvcrt.open_osfhandle(stderr_wh, 0)
-        elif stderr == STDOUT:
-            stderr_wfd = stdout_wfd
-        else:
-            stderr_wfd = stderr
-        try:
-            super().__init__(
-                args, stdin=stdin_rfd, stdout=stdout_wfd, stderr=stderr_wfd, **kwds
-            )
-        except:
-            for h in (stdin_wh, stdout_rh, stderr_rh):
-                if h is not None:
-                    _winapi.CloseHandle(h)
-            raise
-        else:
-            if stdin_wh is not None:
-                self.stdin = PipeHandle(stdin_wh)
-            if stdout_rh is not None:
-                self.stdout = PipeHandle(stdout_rh)
-            if stderr_rh is not None:
-                self.stderr = PipeHandle(stderr_rh)
-        finally:
-            if stdin == PIPE:
-                os.close(stdin_rfd)
-            if stdout == PIPE:
-                os.close(stdout_wfd)
-            if stderr == PIPE:
-                os.close(stderr_wfd)
diff --git a/addon/globalPlugins/spellcheck/libs/certifi/__init__.py b/addon/globalPlugins/spellcheck/libs/certifi/__init__.py
deleted file mode 100644
index eebdf88..0000000
--- a/addon/globalPlugins/spellcheck/libs/certifi/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .core import contents, where
-
-__version__ = "2021.05.30"
diff --git a/addon/globalPlugins/spellcheck/libs/certifi/__main__.py b/addon/globalPlugins/spellcheck/libs/certifi/__main__.py
deleted file mode 100644
index 8945b5d..0000000
--- a/addon/globalPlugins/spellcheck/libs/certifi/__main__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import argparse
-
-from certifi import contents, where
-
-parser = argparse.ArgumentParser()
-parser.add_argument("-c", "--contents", action="store_true")
-args = parser.parse_args()
-
-if args.contents:
-    print(contents())
-else:
-    print(where())
diff --git a/addon/globalPlugins/spellcheck/libs/certifi/cacert.pem b/addon/globalPlugins/spellcheck/libs/certifi/cacert.pem
deleted file mode 100644
index 96e2fc6..0000000
--- a/addon/globalPlugins/spellcheck/libs/certifi/cacert.pem
+++ /dev/null
@@ -1,4257 +0,0 @@
-
-# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
-# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
-# Label: "GlobalSign Root CA"
-# Serial: 4835703278459707669005204
-# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
-# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
-# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
------BEGIN CERTIFICATE-----
-MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
-A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
-b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
-MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
-YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
-aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
-jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
-xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
-1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
-snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
-U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
-9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
-BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
-AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
-yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
-38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
-AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
-DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
-HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
-# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
-# Label: "GlobalSign Root CA - R2"
-# Serial: 4835703278459682885658125
-# MD5 Fingerprint: 94:14:77:7e:3e:5e:fd:8f:30:bd:41:b0:cf:e7:d0:30
-# SHA1 Fingerprint: 75:e0:ab:b6:13:85:12:27:1c:04:f8:5f:dd:de:38:e4:b7:24:2e:fe
-# SHA256 Fingerprint: ca:42:dd:41:74:5f:d0:b8:1e:b9:02:36:2c:f9:d8:bf:71:9d:a1:bd:1b:1e:fc:94:6f:5b:4c:99:f4:2c:1b:9e
------BEGIN CERTIFICATE-----
-MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G
-A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp
-Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1
-MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG
-A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
-hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL
-v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8
-eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq
-tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd
-C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa
-zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB
-mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH
-V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n
-bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG
-3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs
-J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO
-291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS
-ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd
-AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7
-TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg==
------END CERTIFICATE-----
-
-# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
-# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
-# Label: "Entrust.net Premium 2048 Secure Server CA"
-# Serial: 946069240
-# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90
-# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31
-# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77
------BEGIN CERTIFICATE-----
-MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
-RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
-bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
-IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
-ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3
-MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
-LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
-YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
-A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
-K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
-sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
-MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
-XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
-HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
-4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
-HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub
-j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo
-U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf
-zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b
-u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+
-bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er
-fF6adulZkMV8gzURZVE=
------END CERTIFICATE-----
-
-# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
-# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
-# Label: "Baltimore CyberTrust Root"
-# Serial: 33554617
-# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
-# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
-# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
------BEGIN CERTIFICATE-----
-MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
-RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
-VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
-DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
-ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
-VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
-mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
-IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
-mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
-XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
-dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
-jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
-BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
-DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
-9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
-jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
-Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
-ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
-R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
------END CERTIFICATE-----
-
-# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
-# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
-# Label: "Entrust Root Certification Authority"
-# Serial: 1164660820
-# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
-# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
-# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
------BEGIN CERTIFICATE-----
-MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
-VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
-Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
-KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
-cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
-NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
-NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
-ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
-BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
-KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
-Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
-4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
-KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
-rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
-94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
-sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
-gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
-kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
-vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
-A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
-O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
-AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
-9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
-eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
-0vdXcDazv/wor3ElhVsT/h5/WrQ8
------END CERTIFICATE-----
-
-# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
-# Subject: CN=AAA Certificate Services O=Comodo CA Limited
-# Label: "Comodo AAA Services root"
-# Serial: 1
-# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
-# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
-# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
------BEGIN CERTIFICATE-----
-MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
-MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
-GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
-YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
-MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
-BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
-GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
-ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
-BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
-3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
-YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
-rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
-ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
-oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
-MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
-QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
-b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
-AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
-GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
-Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
-G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
-l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
-smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
------END CERTIFICATE-----
-
-# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited
-# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited
-# Label: "QuoVadis Root CA 2"
-# Serial: 1289
-# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b
-# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7
-# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86
------BEGIN CERTIFICATE-----
-MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x
-GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv
-b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV
-BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W
-YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa
-GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg
-Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J
-WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB
-rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp
-+ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1
-ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i
-Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz
-PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og
-/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH
-oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI
-yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud
-EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2
-A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL
-MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT
-ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f
-BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn
-g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl
-fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K
-WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha
-B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc
-hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR
-TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD
-mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z
-ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y
-4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza
-8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u
------END CERTIFICATE-----
-
-# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited
-# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited
-# Label: "QuoVadis Root CA 3"
-# Serial: 1478
-# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf
-# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85
-# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35
------BEGIN CERTIFICATE-----
-MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x
-GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv
-b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV
-BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W
-YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM
-V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB
-4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr
-H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd
-8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv
-vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT
-mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe
-btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc
-T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt
-WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ
-c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A
-4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD
-VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG
-CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0
-aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0
-aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu
-dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw
-czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G
-A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC
-TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg
-Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0
-7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem
-d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd
-+LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B
-4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN
-t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x
-DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57
-k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s
-zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j
-Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT
-mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK
-4SVhM7JZG+Ju1zdXtg2pEto=
------END CERTIFICATE-----
-
-# Issuer: O=SECOM Trust.net OU=Security Communication RootCA1
-# Subject: O=SECOM Trust.net OU=Security Communication RootCA1
-# Label: "Security Communication Root CA"
-# Serial: 0
-# MD5 Fingerprint: f1:bc:63:6a:54:e0:b5:27:f5:cd:e7:1a:e3:4d:6e:4a
-# SHA1 Fingerprint: 36:b1:2b:49:f9:81:9e:d7:4c:9e:bc:38:0f:c6:56:8f:5d:ac:b2:f7
-# SHA256 Fingerprint: e7:5e:72:ed:9f:56:0e:ec:6e:b4:80:00:73:a4:3f:c3:ad:19:19:5a:39:22:82:01:78:95:97:4a:99:02:6b:6c
------BEGIN CERTIFICATE-----
-MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY
-MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t
-dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5
-WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD
-VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3
-DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8
-9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ
-DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9
-Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N
-QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ
-xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G
-A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T
-AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG
-kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr
-Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5
-Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU
-JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot
-RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw==
------END CERTIFICATE-----
-
-# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
-# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
-# Label: "XRamp Global CA Root"
-# Serial: 107108908803651509692980124233745014957
-# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
-# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
-# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
------BEGIN CERTIFICATE-----
-MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
-gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
-MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
-UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
-NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
-dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
-dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
-dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
-38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
-KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
-DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
-qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
-JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
-PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
-BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
-jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
-eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
-ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
-vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
-qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
-IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
-i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
-O+7ETPTsJ3xCwnR8gooJybQDJbw=
------END CERTIFICATE-----
-
-# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
-# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
-# Label: "Go Daddy Class 2 CA"
-# Serial: 0
-# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
-# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
-# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
------BEGIN CERTIFICATE-----
-MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
-MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
-YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
-MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
-ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
-MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
-ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
-PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
-wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
-EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
-avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
-YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
-sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
-/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
-IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
-YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
-ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
-OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
-TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
-HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
-dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
-ReYNnyicsbkqWletNw+vHX/bvZ8=
------END CERTIFICATE-----
-
-# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
-# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
-# Label: "Starfield Class 2 CA"
-# Serial: 0
-# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
-# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
-# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
------BEGIN CERTIFICATE-----
-MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
-MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
-U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
-NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
-ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
-ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
-DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
-8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
-+lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
-X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
-K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
-1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
-A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
-zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
-YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
-bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
-DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
-L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
-eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
-xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
-VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
-WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Assured ID Root CA"
-# Serial: 17154717934120587862167794914071425081
-# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
-# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
-# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
------BEGIN CERTIFICATE-----
-MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
-b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
-EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
-cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
-MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
-JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
-mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
-wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
-VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
-AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
-AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
-BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
-pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
-dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
-fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
-NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
-H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
-+o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Global Root CA"
-# Serial: 10944719598952040374951832963794454346
-# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
-# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
-# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
------BEGIN CERTIFICATE-----
-MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
-QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
-MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
-b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
-9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
-CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
-nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
-43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
-T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
-gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
-BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
-TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
-DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
-hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
-06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
-PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
-YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
-CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert High Assurance EV Root CA"
-# Serial: 3553400076410547919724730734378100087
-# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
-# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
-# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
------BEGIN CERTIFICATE-----
-MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
-ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
-MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
-LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
-RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
-+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
-PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
-xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
-Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
-hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
-EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
-MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
-FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
-nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
-eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
-hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
-Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
-vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
-+OkuE6N36B9K
------END CERTIFICATE-----
-
-# Issuer: CN=DST Root CA X3 O=Digital Signature Trust Co.
-# Subject: CN=DST Root CA X3 O=Digital Signature Trust Co.
-# Label: "DST Root CA X3"
-# Serial: 91299735575339953335919266965803778155
-# MD5 Fingerprint: 41:03:52:dc:0f:f7:50:1b:16:f0:02:8e:ba:6f:45:c5
-# SHA1 Fingerprint: da:c9:02:4f:54:d8:f6:df:94:93:5f:b1:73:26:38:ca:6a:d7:7c:13
-# SHA256 Fingerprint: 06:87:26:03:31:a7:24:03:d9:09:f1:05:e6:9b:cf:0d:32:e1:bd:24:93:ff:c6:d9:20:6d:11:bc:d6:77:07:39
------BEGIN CERTIFICATE-----
-MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/
-MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT
-DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow
-PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD
-Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
-AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O
-rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq
-OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b
-xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw
-7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD
-aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV
-HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG
-SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69
-ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr
-AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz
-R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5
-JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo
-Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ
------END CERTIFICATE-----
-
-# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG
-# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG
-# Label: "SwissSign Gold CA - G2"
-# Serial: 13492815561806991280
-# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93
-# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61
-# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95
------BEGIN CERTIFICATE-----
-MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV
-BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln
-biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF
-MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT
-d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC
-CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8
-76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+
-bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c
-6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE
-emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd
-MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt
-MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y
-MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y
-FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi
-aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM
-gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB
-qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7
-lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn
-8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov
-L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6
-45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO
-UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5
-O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC
-bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv
-GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a
-77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC
-hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3
-92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp
-Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w
-ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt
-Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ
------END CERTIFICATE-----
-
-# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG
-# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG
-# Label: "SwissSign Silver CA - G2"
-# Serial: 5700383053117599563
-# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13
-# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb
-# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5
------BEGIN CERTIFICATE-----
-MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE
-BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu
-IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow
-RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY
-U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
-MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv
-Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br
-YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF
-nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH
-6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt
-eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/
-c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ
-MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH
-HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf
-jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6
-5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB
-rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU
-F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c
-wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0
-cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB
-AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp
-WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9
-xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ
-2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ
-IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8
-aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X
-em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR
-dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/
-OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+
-hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy
-tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u
------END CERTIFICATE-----
-
-# Issuer: CN=SecureTrust CA O=SecureTrust Corporation
-# Subject: CN=SecureTrust CA O=SecureTrust Corporation
-# Label: "SecureTrust CA"
-# Serial: 17199774589125277788362757014266862032
-# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1
-# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11
-# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73
------BEGIN CERTIFICATE-----
-MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
-MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
-FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
-MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
-cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
-AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
-Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
-0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
-wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
-7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
-8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
-BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
-/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
-JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
-NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
-6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
-3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
-D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
-CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
-3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
------END CERTIFICATE-----
-
-# Issuer: CN=Secure Global CA O=SecureTrust Corporation
-# Subject: CN=Secure Global CA O=SecureTrust Corporation
-# Label: "Secure Global CA"
-# Serial: 9751836167731051554232119481456978597
-# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de
-# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b
-# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69
------BEGIN CERTIFICATE-----
-MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
-MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
-GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
-MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
-Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
-SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
-iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
-/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
-jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
-HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
-sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
-gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
-MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
-KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
-AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
-URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
-H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
-I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
-iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
-f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
------END CERTIFICATE-----
-
-# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
-# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
-# Label: "COMODO Certification Authority"
-# Serial: 104350513648249232941998508985834464573
-# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
-# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
-# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
------BEGIN CERTIFICATE-----
-MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
-gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
-A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
-BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
-MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
-YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
-RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
-aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
-UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
-2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
-Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
-+2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
-DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
-nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
-/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
-PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
-QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
-SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
-IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
-RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
-zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
-BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
-ZQ==
------END CERTIFICATE-----
-
-# Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
-# Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
-# Label: "Network Solutions Certificate Authority"
-# Serial: 116697915152937497490437556386812487904
-# MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e
-# SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce
-# SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c
------BEGIN CERTIFICATE-----
-MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi
-MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu
-MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp
-dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV
-UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO
-ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG
-SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz
-c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP
-OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl
-mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF
-BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4
-qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw
-gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB
-BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu
-bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp
-dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8
-6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/
-h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH
-/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv
-wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN
-pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey
------END CERTIFICATE-----
-
-# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
-# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
-# Label: "COMODO ECC Certification Authority"
-# Serial: 41578283867086692638256921589707938090
-# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
-# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
-# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
------BEGIN CERTIFICATE-----
-MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
-MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
-BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
-IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
-MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
-ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
-T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
-biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
-FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
-cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
-BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
-BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
-fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
-GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
------END CERTIFICATE-----
-
-# Issuer: CN=Certigna O=Dhimyotis
-# Subject: CN=Certigna O=Dhimyotis
-# Label: "Certigna"
-# Serial: 18364802974209362175
-# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff
-# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97
-# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d
------BEGIN CERTIFICATE-----
-MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV
-BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X
-DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ
-BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3
-DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4
-QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny
-gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw
-zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q
-130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2
-JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw
-DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw
-ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT
-AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj
-AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG
-9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h
-bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc
-fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu
-HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w
-t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
-WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
------END CERTIFICATE-----
-
-# Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc
-# Subject: CN=Cybertrust Global Root O=Cybertrust, Inc
-# Label: "Cybertrust Global Root"
-# Serial: 4835703278459682877484360
-# MD5 Fingerprint: 72:e4:4a:87:e3:69:40:80:77:ea:bc:e3:f4:ff:f0:e1
-# SHA1 Fingerprint: 5f:43:e5:b1:bf:f8:78:8c:ac:1c:c7:ca:4a:9a:c6:22:2b:cc:34:c6
-# SHA256 Fingerprint: 96:0a:df:00:63:e9:63:56:75:0c:29:65:dd:0a:08:67:da:0b:9c:bd:6e:77:71:4a:ea:fb:23:49:ab:39:3d:a3
------BEGIN CERTIFICATE-----
-MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG
-A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh
-bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE
-ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS
-b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5
-7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS
-J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y
-HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP
-t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz
-FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY
-XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/
-MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw
-hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js
-MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA
-A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj
-Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx
-XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o
-omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc
-A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW
-WL1WMRJOEcgh4LMRkWXbtKaIOM5V
------END CERTIFICATE-----
-
-# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
-# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
-# Label: "ePKI Root Certification Authority"
-# Serial: 28956088682735189655030529057352760477
-# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3
-# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0
-# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5
------BEGIN CERTIFICATE-----
-MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe
-MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0
-ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe
-Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw
-IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL
-SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF
-AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH
-SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh
-ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X
-DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1
-TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ
-fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA
-sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU
-WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS
-nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH
-dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip
-NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC
-AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF
-MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH
-ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB
-uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl
-PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP
-JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/
-gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2
-j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6
-5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB
-o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS
-/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z
-Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE
-W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D
-hNQ+IIX3Sj0rnP0qCglN6oH4EZw=
------END CERTIFICATE-----
-
-# Issuer: O=certSIGN OU=certSIGN ROOT CA
-# Subject: O=certSIGN OU=certSIGN ROOT CA
-# Label: "certSIGN ROOT CA"
-# Serial: 35210227249154
-# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17
-# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b
-# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb
------BEGIN CERTIFICATE-----
-MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT
-AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD
-QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP
-MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC
-ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do
-0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ
-UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d
-RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ
-OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv
-JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C
-AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O
-BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ
-LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY
-MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ
-44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I
-Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw
-i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN
-9u6wWk5JRFRYX0KD
------END CERTIFICATE-----
-
-# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
-# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
-# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny"
-# Serial: 80544274841616
-# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88
-# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91
-# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98
------BEGIN CERTIFICATE-----
-MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG
-EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3
-MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl
-cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR
-dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB
-pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM
-b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm
-aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz
-IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT
-lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz
-AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5
-VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG
-ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2
-BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG
-AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M
-U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh
-bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C
-+C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
-bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F
-uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
-XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
------END CERTIFICATE-----
-
-# Issuer: CN=Hongkong Post Root CA 1 O=Hongkong Post
-# Subject: CN=Hongkong Post Root CA 1 O=Hongkong Post
-# Label: "Hongkong Post Root CA 1"
-# Serial: 1000
-# MD5 Fingerprint: a8:0d:6f:39:78:b9:43:6d:77:42:6d:98:5a:cc:23:ca
-# SHA1 Fingerprint: d6:da:a8:20:8d:09:d2:15:4d:24:b5:2f:cb:34:6e:b2:58:b2:8a:58
-# SHA256 Fingerprint: f9:e6:7d:33:6c:51:00:2a:c0:54:c6:32:02:2d:66:dd:a2:e7:e3:ff:f1:0a:d0:61:ed:31:d8:bb:b4:10:cf:b2
------BEGIN CERTIFICATE-----
-MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx
-FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg
-Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG
-A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr
-b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
-AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ
-jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn
-PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh
-ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9
-nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h
-q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED
-MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC
-mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3
-7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB
-oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs
-EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO
-fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi
-AmvZWg==
------END CERTIFICATE-----
-
-# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
-# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
-# Label: "SecureSign RootCA11"
-# Serial: 1
-# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26
-# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3
-# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12
------BEGIN CERTIFICATE-----
-MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr
-MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG
-A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0
-MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp
-Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD
-QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz
-i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8
-h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV
-MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9
-UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni
-8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC
-h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD
-VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB
-AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm
-KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ
-X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr
-QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5
-pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN
-QSdJQO7e5iNEOdyhIta6A/I=
------END CERTIFICATE-----
-
-# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
-# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
-# Label: "Microsec e-Szigno Root CA 2009"
-# Serial: 14014712776195784473
-# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1
-# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e
-# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78
------BEGIN CERTIFICATE-----
-MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
-VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0
-ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G
-CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y
-OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx
-FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp
-Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o
-dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP
-kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc
-cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U
-fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7
-N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC
-xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1
-+rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
-A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM
-Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG
-SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h
-mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk
-ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775
-tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c
-2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t
-HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
-# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
-# Label: "GlobalSign Root CA - R3"
-# Serial: 4835703278459759426209954
-# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
-# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
-# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
------BEGIN CERTIFICATE-----
-MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
-A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
-Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
-MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
-A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
-hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
-RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
-gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
-KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
-QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
-XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
-DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
-LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
-RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
-jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
-6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
-mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
-Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
-WD9f
------END CERTIFICATE-----
-
-# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
-# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
-# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
-# Serial: 6047274297262753887
-# MD5 Fingerprint: 73:3a:74:7a:ec:bb:a3:96:a6:c2:e4:e2:c8:9b:c0:c3
-# SHA1 Fingerprint: ae:c5:fb:3f:c8:e1:bf:c4:e5:4f:03:07:5a:9a:e8:00:b7:f7:b6:fa
-# SHA256 Fingerprint: 04:04:80:28:bf:1f:28:64:d4:8f:9a:d4:d8:32:94:36:6a:82:88:56:55:3f:3b:14:30:3f:90:14:7f:5d:40:ef
------BEGIN CERTIFICATE-----
-MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE
-BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h
-cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy
-MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg
-Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi
-MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9
-thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM
-cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG
-L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i
-NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h
-X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b
-m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy
-Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja
-EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T
-KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF
-6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh
-OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD
-VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD
-VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp
-cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv
-ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl
-AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF
-661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9
-am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1
-ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481
-PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS
-3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k
-SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF
-3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM
-ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g
-StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz
-Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB
-jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V
------END CERTIFICATE-----
-
-# Issuer: CN=Izenpe.com O=IZENPE S.A.
-# Subject: CN=Izenpe.com O=IZENPE S.A.
-# Label: "Izenpe.com"
-# Serial: 917563065490389241595536686991402621
-# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73
-# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19
-# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f
------BEGIN CERTIFICATE-----
-MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4
-MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6
-ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD
-VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j
-b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq
-scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO
-xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H
-LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX
-uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD
-yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+
-JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q
-rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN
-BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L
-hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB
-QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+
-HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu
-Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg
-QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB
-BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx
-MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
-AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA
-A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb
-laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56
-awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo
-JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw
-LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT
-VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk
-LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb
-UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/
-QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+
-naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls
-QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw==
------END CERTIFICATE-----
-
-# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
-# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
-# Label: "Go Daddy Root Certificate Authority - G2"
-# Serial: 0
-# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
-# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
-# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
------BEGIN CERTIFICATE-----
-MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
-EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
-EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
-ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
-NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
-EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
-AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
-DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
-E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
-/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
-DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
-GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
-tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
-AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
-FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
-WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
-9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
-gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
-2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
-LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
-4uJEvlz36hz1
------END CERTIFICATE-----
-
-# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
-# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
-# Label: "Starfield Root Certificate Authority - G2"
-# Serial: 0
-# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
-# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
-# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
------BEGIN CERTIFICATE-----
-MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
-EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
-HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
-ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
-MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
-b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
-aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
-Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
-ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
-nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
-HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
-Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
-dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
-HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
-BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
-CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
-sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
-4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
-8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
-pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
-mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
------END CERTIFICATE-----
-
-# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
-# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
-# Label: "Starfield Services Root Certificate Authority - G2"
-# Serial: 0
-# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
-# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
-# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
------BEGIN CERTIFICATE-----
-MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
-EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
-HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
-ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
-MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
-VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
-ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
-dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
-hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
-OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
-8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
-Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
-hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
-6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
-DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
-AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
-bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
-ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
-qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
-iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
-0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
-sSi6
------END CERTIFICATE-----
-
-# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
-# Subject: CN=AffirmTrust Commercial O=AffirmTrust
-# Label: "AffirmTrust Commercial"
-# Serial: 8608355977964138876
-# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
-# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
-# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
------BEGIN CERTIFICATE-----
-MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
-BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
-dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
-MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
-cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
-AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
-Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
-ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
-MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
-yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
-VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
-nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
-KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
-XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
-vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
-Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
-N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
-nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
------END CERTIFICATE-----
-
-# Issuer: CN=AffirmTrust Networking O=AffirmTrust
-# Subject: CN=AffirmTrust Networking O=AffirmTrust
-# Label: "AffirmTrust Networking"
-# Serial: 8957382827206547757
-# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
-# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
-# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
------BEGIN CERTIFICATE-----
-MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
-BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
-dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
-MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
-cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
-AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
-YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
-kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
-QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
-6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
-yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
-QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
-KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
-tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
-QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
-Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
-olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
-x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
------END CERTIFICATE-----
-
-# Issuer: CN=AffirmTrust Premium O=AffirmTrust
-# Subject: CN=AffirmTrust Premium O=AffirmTrust
-# Label: "AffirmTrust Premium"
-# Serial: 7893706540734352110
-# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
-# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
-# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
------BEGIN CERTIFICATE-----
-MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
-BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
-dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
-A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
-cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
-qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
-JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
-+jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
-s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
-HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
-70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
-V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
-qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
-5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
-C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
-OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
-FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
-BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
-KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
-Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
-8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
-MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
-0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
-u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
-u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
-YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
-GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
-RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
-KeC2uAloGRwYQw==
------END CERTIFICATE-----
-
-# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
-# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
-# Label: "AffirmTrust Premium ECC"
-# Serial: 8401224907861490260
-# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
-# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
-# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
------BEGIN CERTIFICATE-----
-MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
-VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
-cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
-BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
-VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
-0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
-ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
-A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
-A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
-aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
-flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
------END CERTIFICATE-----
-
-# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
-# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
-# Label: "Certum Trusted Network CA"
-# Serial: 279744
-# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78
-# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e
-# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e
------BEGIN CERTIFICATE-----
-MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM
-MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D
-ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU
-cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3
-WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg
-Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw
-IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH
-UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM
-TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU
-BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM
-kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x
-AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV
-HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV
-HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y
-sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL
-I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8
-J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY
-VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
-03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw=
------END CERTIFICATE-----
-
-# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
-# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
-# Label: "TWCA Root Certification Authority"
-# Serial: 1
-# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79
-# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48
-# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44
------BEGIN CERTIFICATE-----
-MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES
-MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU
-V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz
-WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO
-LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm
-aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
-AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE
-AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH
-K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX
-RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z
-rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx
-3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
-HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq
-hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC
-MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls
-XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D
-lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn
-aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ
-YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw==
------END CERTIFICATE-----
-
-# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
-# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
-# Label: "Security Communication RootCA2"
-# Serial: 0
-# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43
-# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74
-# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6
------BEGIN CERTIFICATE-----
-MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl
-MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe
-U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX
-DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy
-dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj
-YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV
-OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr
-zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM
-VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ
-hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO
-ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw
-awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs
-OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
-DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF
-coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc
-okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8
-t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
-1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/
-SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
------END CERTIFICATE-----
-
-# Issuer: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
-# Subject: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
-# Label: "EC-ACC"
-# Serial: -23701579247955709139626555126524820479
-# MD5 Fingerprint: eb:f5:9d:29:0d:61:f9:42:1f:7c:c2:ba:6d:e3:15:09
-# SHA1 Fingerprint: 28:90:3a:63:5b:52:80:fa:e6:77:4c:0b:6d:a7:d6:ba:a6:4a:f2:e8
-# SHA256 Fingerprint: 88:49:7f:01:60:2f:31:54:24:6a:e2:8c:4d:5a:ef:10:f1:d8:7e:bb:76:62:6f:4a:e0:b7:f9:5b:a7:96:87:99
------BEGIN CERTIFICATE-----
-MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB
-8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy
-dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1
-YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3
-dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh
-IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD
-LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG
-EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g
-KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD
-ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu
-bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg
-ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN
-BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R
-85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm
-4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV
-HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd
-QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t
-lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB
-o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E
-BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4
-opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo
-dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW
-ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN
-AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y
-/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k
-SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy
-Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS
-Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl
-nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI=
------END CERTIFICATE-----
-
-# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
-# Subject: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
-# Label: "Hellenic Academic and Research Institutions RootCA 2011"
-# Serial: 0
-# MD5 Fingerprint: 73:9f:4c:4b:73:5b:79:e9:fa:ba:1c:ef:6e:cb:d5:c9
-# SHA1 Fingerprint: fe:45:65:9b:79:03:5b:98:a1:61:b5:51:2e:ac:da:58:09:48:22:4d
-# SHA256 Fingerprint: bc:10:4f:15:a4:8b:e7:09:dc:a5:42:a7:e1:d4:b9:df:6f:05:45:27:e8:02:ea:a9:2d:59:54:44:25:8a:fe:71
------BEGIN CERTIFICATE-----
-MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix
-RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1
-dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p
-YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw
-NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK
-EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl
-cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
-c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB
-BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz
-dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ
-fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns
-bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD
-75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP
-FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV
-HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp
-5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu
-b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA
-A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p
-6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8
-TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7
-dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys
-Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI
-l7WdmplNsDz4SgCbZN2fOUvRJ9e4
------END CERTIFICATE-----
-
-# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
-# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
-# Label: "Actalis Authentication Root CA"
-# Serial: 6271844772424770508
-# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6
-# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac
-# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66
------BEGIN CERTIFICATE-----
-MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJKoZIhvcNAQELBQAwazELMAkGA1UE
-BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8w
-MzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290
-IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UEBhMC
-SVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1
-ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENB
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNv
-UTufClrJwkg4CsIcoBh/kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX
-4ay8IMKx4INRimlNAJZaby/ARH6jDuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9
-KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9E1fAXdKDa0hMxKufgFpbOr3JpyI/
-gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1fYVEiVRvjRuPjPdA1Yprb
-rxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+locePGX2oxgkg4YQ
-51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8Pu2F
-be8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxe
-KF+w6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4F
-v6MGn8i1zeQf1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbn
-fpb2U8WANFAoWPASUHEXMLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7
-jPKxwV2dpAtMK9myGPW1n0sCAwEAAaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7Ynz
-ezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUUtiIOsifeGbt
-ifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAL
-e3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07GjLukD0R0i70
-jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a2fDz
-WochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4V
-SM0RFbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9j
-pwlCCRT8AKnCgHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyX
-X04fkZT6/iyj2HYauE2yOE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+Ok
-fcvHlXHo2qN8xcL4dJIEG4aspCJTQLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7R
-K4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+tguLHPPAUJ4lueAI3jZm/zel0btU
-ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU
-LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT
-LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg==
------END CERTIFICATE-----
-
-# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
-# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
-# Label: "Buypass Class 2 Root CA"
-# Serial: 2
-# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29
-# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99
-# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48
------BEGIN CERTIFICATE-----
-MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
-MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
-Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow
-TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
-HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
-BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr
-6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV
-L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91
-1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx
-MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ
-QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB
-arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr
-Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi
-FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS
-P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN
-9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP
-AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz
-uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h
-9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s
-A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t
-OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo
-+fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7
-KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2
-DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us
-H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ
-I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7
-5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h
-3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz
-Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA=
------END CERTIFICATE-----
-
-# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
-# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
-# Label: "Buypass Class 3 Root CA"
-# Serial: 2
-# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec
-# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57
-# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d
------BEGIN CERTIFICATE-----
-MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
-MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
-Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow
-TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
-HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
-BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y
-ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E
-N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9
-tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX
-0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c
-/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X
-KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY
-zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS
-O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D
-34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP
-K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3
-AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv
-Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj
-QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV
-cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS
-IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2
-HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa
-O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv
-033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u
-dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE
-kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41
-3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD
-u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq
-4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc=
------END CERTIFICATE-----
-
-# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
-# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
-# Label: "T-TeleSec GlobalRoot Class 3"
-# Serial: 1
-# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef
-# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1
-# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd
------BEGIN CERTIFICATE-----
-MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
-KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
-BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
-YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
-OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
-aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
-ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
-CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
-8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
-RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
-hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
-ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
-EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
-QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
-A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
-WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
-1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
-6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
-91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
-e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
-TpPDpFQUWw==
------END CERTIFICATE-----
-
-# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
-# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
-# Label: "D-TRUST Root Class 3 CA 2 2009"
-# Serial: 623603
-# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f
-# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0
-# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1
------BEGIN CERTIFICATE-----
-MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF
-MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD
-bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha
-ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM
-HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB
-BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03
-UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42
-tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R
-ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM
-lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp
-/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G
-A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G
-A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj
-dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy
-MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl
-cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js
-L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL
-BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni
-acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0
-o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K
-zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8
-PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y
-Johw1+qRzT65ysCQblrGXnRl11z+o+I=
------END CERTIFICATE-----
-
-# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
-# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
-# Label: "D-TRUST Root Class 3 CA 2 EV 2009"
-# Serial: 623604
-# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6
-# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83
-# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81
------BEGIN CERTIFICATE-----
-MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF
-MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD
-bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw
-NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV
-BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI
-hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn
-ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0
-3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z
-qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR
-p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8
-HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw
-ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea
-HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw
-Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh
-c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E
-RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt
-dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku
-Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp
-3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05
-nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF
-CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
-xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
-KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
------END CERTIFICATE-----
-
-# Issuer: CN=CA Disig Root R2 O=Disig a.s.
-# Subject: CN=CA Disig Root R2 O=Disig a.s.
-# Label: "CA Disig Root R2"
-# Serial: 10572350602393338211
-# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03
-# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71
-# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03
------BEGIN CERTIFICATE-----
-MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV
-BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu
-MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy
-MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx
-EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw
-ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe
-NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH
-PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I
-x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe
-QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR
-yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO
-QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912
-H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ
-QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD
-i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs
-nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1
-rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
-DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI
-hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM
-tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf
-GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb
-lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka
-+elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal
-TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i
-nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3
-gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr
-G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os
-zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x
-L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL
------END CERTIFICATE-----
-
-# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
-# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
-# Label: "ACCVRAIZ1"
-# Serial: 6828503384748696800
-# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02
-# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17
-# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13
------BEGIN CERTIFICATE-----
-MIIH0zCCBbugAwIBAgIIXsO3pkN/pOAwDQYJKoZIhvcNAQEFBQAwQjESMBAGA1UE
-AwwJQUNDVlJBSVoxMRAwDgYDVQQLDAdQS0lBQ0NWMQ0wCwYDVQQKDARBQ0NWMQsw
-CQYDVQQGEwJFUzAeFw0xMTA1MDUwOTM3MzdaFw0zMDEyMzEwOTM3MzdaMEIxEjAQ
-BgNVBAMMCUFDQ1ZSQUlaMTEQMA4GA1UECwwHUEtJQUNDVjENMAsGA1UECgwEQUND
-VjELMAkGA1UEBhMCRVMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCb
-qau/YUqXry+XZpp0X9DZlv3P4uRm7x8fRzPCRKPfmt4ftVTdFXxpNRFvu8gMjmoY
-HtiP2Ra8EEg2XPBjs5BaXCQ316PWywlxufEBcoSwfdtNgM3802/J+Nq2DoLSRYWo
-G2ioPej0RGy9ocLLA76MPhMAhN9KSMDjIgro6TenGEyxCQ0jVn8ETdkXhBilyNpA
-lHPrzg5XPAOBOp0KoVdDaaxXbXmQeOW1tDvYvEyNKKGno6e6Ak4l0Squ7a4DIrhr
-IA8wKFSVf+DuzgpmndFALW4ir50awQUZ0m/A8p/4e7MCQvtQqR0tkw8jq8bBD5L/
-0KIV9VMJcRz/RROE5iZe+OCIHAr8Fraocwa48GOEAqDGWuzndN9wrqODJerWx5eH
-k6fGioozl2A3ED6XPm4pFdahD9GILBKfb6qkxkLrQaLjlUPTAYVtjrs78yM2x/47
-4KElB0iryYl0/wiPgL/AlmXz7uxLaL2diMMxs0Dx6M/2OLuc5NF/1OVYm3z61PMO
-m3WR5LpSLhl+0fXNWhn8ugb2+1KoS5kE3fj5tItQo05iifCHJPqDQsGH+tUtKSpa
-cXpkatcnYGMN285J9Y0fkIkyF/hzQ7jSWpOGYdbhdQrqeWZ2iE9x6wQl1gpaepPl
-uUsXQA+xtrn13k/c4LOsOxFwYIRKQ26ZIMApcQrAZQIDAQABo4ICyzCCAscwfQYI
-KwYBBQUHAQEEcTBvMEwGCCsGAQUFBzAChkBodHRwOi8vd3d3LmFjY3YuZXMvZmls
-ZWFkbWluL0FyY2hpdm9zL2NlcnRpZmljYWRvcy9yYWl6YWNjdjEuY3J0MB8GCCsG
-AQUFBzABhhNodHRwOi8vb2NzcC5hY2N2LmVzMB0GA1UdDgQWBBTSh7Tj3zcnk1X2
-VuqB5TbMjB4/vTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNKHtOPfNyeT
-VfZW6oHlNsyMHj+9MIIBcwYDVR0gBIIBajCCAWYwggFiBgRVHSAAMIIBWDCCASIG
-CCsGAQUFBwICMIIBFB6CARAAQQB1AHQAbwByAGkAZABhAGQAIABkAGUAIABDAGUA
-cgB0AGkAZgBpAGMAYQBjAGkA8wBuACAAUgBhAO0AegAgAGQAZQAgAGwAYQAgAEEA
-QwBDAFYAIAAoAEEAZwBlAG4AYwBpAGEAIABkAGUAIABUAGUAYwBuAG8AbABvAGcA
-7QBhACAAeQAgAEMAZQByAHQAaQBmAGkAYwBhAGMAaQDzAG4AIABFAGwAZQBjAHQA
-cgDzAG4AaQBjAGEALAAgAEMASQBGACAAUQA0ADYAMAAxADEANQA2AEUAKQAuACAA
-QwBQAFMAIABlAG4AIABoAHQAdABwADoALwAvAHcAdwB3AC4AYQBjAGMAdgAuAGUA
-czAwBggrBgEFBQcCARYkaHR0cDovL3d3dy5hY2N2LmVzL2xlZ2lzbGFjaW9uX2Mu
-aHRtMFUGA1UdHwROMEwwSqBIoEaGRGh0dHA6Ly93d3cuYWNjdi5lcy9maWxlYWRt
-aW4vQXJjaGl2b3MvY2VydGlmaWNhZG9zL3JhaXphY2N2MV9kZXIuY3JsMA4GA1Ud
-DwEB/wQEAwIBBjAXBgNVHREEEDAOgQxhY2N2QGFjY3YuZXMwDQYJKoZIhvcNAQEF
-BQADggIBAJcxAp/n/UNnSEQU5CmH7UwoZtCPNdpNYbdKl02125DgBS4OxnnQ8pdp
-D70ER9m+27Up2pvZrqmZ1dM8MJP1jaGo/AaNRPTKFpV8M9xii6g3+CfYCS0b78gU
-JyCpZET/LtZ1qmxNYEAZSUNUY9rizLpm5U9EelvZaoErQNV/+QEnWCzI7UiRfD+m
-AM/EKXMRNt6GGT6d7hmKG9Ww7Y49nCrADdg9ZuM8Db3VlFzi4qc1GwQA9j9ajepD
-vV+JHanBsMyZ4k0ACtrJJ1vnE5Bc5PUzolVt3OAJTS+xJlsndQAJxGJ3KQhfnlms
-tn6tn1QwIgPBHnFk/vk4CpYY3QIUrCPLBhwepH2NDd4nQeit2hW3sCPdK6jT2iWH
-7ehVRE2I9DZ+hJp4rPcOVkkO1jMl1oRQQmwgEh0q1b688nCBpHBgvgW1m54ERL5h
-I6zppSSMEYCUWqKiuUnSwdzRp+0xESyeGabu4VXhwOrPDYTkF7eifKXeVSUG7szA
-h1xA2syVP1XgNce4hL60Xc16gwFy7ofmXx2utYXGJt/mwZrpHgJHnyqobalbz+xF
-d3+YJ5oyXSrjhO7FmGYvliAd3djDJ9ew+f7Zfc3Qn48LFFhRny+Lwzgt3uiP1o2H
-pPVWQxaZLPSkVrQ0uGE3ycJYgBugl6H8WY3pEfbRD0tVNEYqi4Y7
------END CERTIFICATE-----
-
-# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
-# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
-# Label: "TWCA Global Root CA"
-# Serial: 3262
-# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96
-# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65
-# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b
------BEGIN CERTIFICATE-----
-MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx
-EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT
-VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5
-NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT
-B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF
-10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz
-0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh
-MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH
-zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc
-46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2
-yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi
-laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP
-oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA
-BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE
-qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm
-4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
-/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL
-1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn
-LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF
-H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo
-RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+
-nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh
-15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW
-6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW
-nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j
-wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz
-aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy
-KwbQBM0=
------END CERTIFICATE-----
-
-# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera
-# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera
-# Label: "TeliaSonera Root CA v1"
-# Serial: 199041966741090107964904287217786801558
-# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c
-# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37
-# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89
------BEGIN CERTIFICATE-----
-MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw
-NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv
-b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD
-VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2
-MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F
-VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1
-7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X
-Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+
-/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs
-81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm
-dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe
-Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu
-sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4
-pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs
-slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ
-arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD
-VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG
-9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl
-dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx
-0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj
-TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed
-Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7
-Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI
-OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7
-vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW
-t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn
-HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx
-SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY=
------END CERTIFICATE-----
-
-# Issuer: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
-# Subject: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi
-# Label: "E-Tugra Certification Authority"
-# Serial: 7667447206703254355
-# MD5 Fingerprint: b8:a1:03:63:b0:bd:21:71:70:8a:6f:13:3a:bb:79:49
-# SHA1 Fingerprint: 51:c6:e7:08:49:06:6e:f3:92:d4:5c:a0:0d:6d:a3:62:8f:c3:52:39
-# SHA256 Fingerprint: b0:bf:d5:2b:b0:d7:d9:bd:92:bf:5d:4d:c1:3d:a2:55:c0:2c:54:2f:37:83:65:ea:89:39:11:f5:5e:55:f2:3c
------BEGIN CERTIFICATE-----
-MIIGSzCCBDOgAwIBAgIIamg+nFGby1MwDQYJKoZIhvcNAQELBQAwgbIxCzAJBgNV
-BAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+BgNVBAoMN0UtVHXEn3JhIEVCRyBC
-aWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhpem1ldGxlcmkgQS7Fni4xJjAkBgNV
-BAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBNZXJrZXppMSgwJgYDVQQDDB9FLVR1
-Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTEzMDMwNTEyMDk0OFoXDTIz
-MDMwMzEyMDk0OFowgbIxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+
-BgNVBAoMN0UtVHXEn3JhIEVCRyBCaWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhp
-em1ldGxlcmkgQS7Fni4xJjAkBgNVBAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBN
-ZXJrZXppMSgwJgYDVQQDDB9FLVR1Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4vU/kwVRHoViVF56C/UY
-B4Oufq9899SKa6VjQzm5S/fDxmSJPZQuVIBSOTkHS0vdhQd2h8y/L5VMzH2nPbxH
-D5hw+IyFHnSOkm0bQNGZDbt1bsipa5rAhDGvykPL6ys06I+XawGb1Q5KCKpbknSF
-Q9OArqGIW66z6l7LFpp3RMih9lRozt6Plyu6W0ACDGQXwLWTzeHxE2bODHnv0ZEo
-q1+gElIwcxmOj+GMB6LDu0rw6h8VqO4lzKRG+Bsi77MOQ7osJLjFLFzUHPhdZL3D
-k14opz8n8Y4e0ypQBaNV2cvnOVPAmJ6MVGKLJrD3fY185MaeZkJVgkfnsliNZvcH
-fC425lAcP9tDJMW/hkd5s3kc91r0E+xs+D/iWR+V7kI+ua2oMoVJl0b+SzGPWsut
-dEcf6ZG33ygEIqDUD13ieU/qbIWGvaimzuT6w+Gzrt48Ue7LE3wBf4QOXVGUnhMM
-ti6lTPk5cDZvlsouDERVxcr6XQKj39ZkjFqzAQqptQpHF//vkUAqjqFGOjGY5RH8
-zLtJVor8udBhmm9lbObDyz51Sf6Pp+KJxWfXnUYTTjF2OySznhFlhqt/7x3U+Lzn
-rFpct1pHXFXOVbQicVtbC/DP3KBhZOqp12gKY6fgDT+gr9Oq0n7vUaDmUStVkhUX
-U8u3Zg5mTPj5dUyQ5xJwx0UCAwEAAaNjMGEwHQYDVR0OBBYEFC7j27JJ0JxUeVz6
-Jyr+zE7S6E5UMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAULuPbsknQnFR5
-XPonKv7MTtLoTlQwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAF
-Nzr0TbdF4kV1JI+2d1LoHNgQk2Xz8lkGpD4eKexd0dCrfOAKkEh47U6YA5n+KGCR
-HTAduGN8qOY1tfrTYXbm1gdLymmasoR6d5NFFxWfJNCYExL/u6Au/U5Mh/jOXKqY
-GwXgAEZKgoClM4so3O0409/lPun++1ndYYRP0lSWE2ETPo+Aab6TR7U1Q9Jauz1c
-77NCR807VRMGsAnb/WP2OogKmW9+4c4bU2pEZiNRCHu8W1Ki/QY3OEBhj0qWuJA3
-+GbHeJAAFS6LrVE1Uweoa2iu+U48BybNCAVwzDk/dr2l02cmAYamU9JgO3xDf1WK
-vJUawSg5TB9D0pH0clmKuVb8P7Sd2nCcdlqMQ1DujjByTd//SffGqWfZbawCEeI6
-FiWnWAjLb1NBnEg4R2gz0dfHj9R0IdTDBZB6/86WiLEVKV0jq9BgoRJP3vQXzTLl
-yb/IQ639Lo7xr+L0mPoSHyDYwKcMhcWQ9DstliaxLL5Mq+ux0orJ23gTDx4JnW2P
-AJ8C2sH6H3p6CcRK5ogql5+Ji/03X186zjhZhkuvcQu02PJwT58yE+Owp1fl2tpD
-y4Q08ijE6m30Ku/Ba3ba+367hTzSU8JNvnHhRdH9I2cNE3X7z2VnIp2usAnRCf8d
-NL/+I5c30jn6PQ0GC7TbO6Orb1wdtn7os4I07QZcJA==
------END CERTIFICATE-----
-
-# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
-# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
-# Label: "T-TeleSec GlobalRoot Class 2"
-# Serial: 1
-# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a
-# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9
-# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52
------BEGIN CERTIFICATE-----
-MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
-KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
-BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
-YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1
-OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
-aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
-ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G
-CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd
-AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC
-FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi
-1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq
-jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ
-wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj
-QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/
-WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy
-NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC
-uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw
-IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6
-g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN
-9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP
-BSeOE6Fuwg==
------END CERTIFICATE-----
-
-# Issuer: CN=Atos TrustedRoot 2011 O=Atos
-# Subject: CN=Atos TrustedRoot 2011 O=Atos
-# Label: "Atos TrustedRoot 2011"
-# Serial: 6643877497813316402
-# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56
-# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21
-# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74
------BEGIN CERTIFICATE-----
-MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE
-AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG
-EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM
-FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC
-REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp
-Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM
-VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+
-SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ
-4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L
-cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi
-eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV
-HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG
-A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3
-DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j
-vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP
-DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc
-maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D
-lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv
-KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed
------END CERTIFICATE-----
-
-# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
-# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
-# Label: "QuoVadis Root CA 1 G3"
-# Serial: 687049649626669250736271037606554624078720034195
-# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab
-# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67
-# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74
------BEGIN CERTIFICATE-----
-MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL
-BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
-BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00
-MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
-aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV
-wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe
-rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341
-68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh
-4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp
-UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o
-abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc
-3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G
-KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt
-hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO
-Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt
-zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
-BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD
-ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC
-MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2
-cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN
-qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5
-YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv
-b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2
-8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k
-NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj
-ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp
-q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt
-nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD
------END CERTIFICATE-----
-
-# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
-# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
-# Label: "QuoVadis Root CA 2 G3"
-# Serial: 390156079458959257446133169266079962026824725800
-# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06
-# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36
-# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40
------BEGIN CERTIFICATE-----
-MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL
-BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
-BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00
-MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
-aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf
-qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW
-n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym
-c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+
-O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1
-o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j
-IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq
-IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz
-8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh
-vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l
-7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG
-cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
-BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD
-ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66
-AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC
-roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga
-W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n
-lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE
-+V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV
-csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd
-dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg
-KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM
-HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4
-WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M
------END CERTIFICATE-----
-
-# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
-# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
-# Label: "QuoVadis Root CA 3 G3"
-# Serial: 268090761170461462463995952157327242137089239581
-# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7
-# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d
-# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46
------BEGIN CERTIFICATE-----
-MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL
-BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
-BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00
-MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
-aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR
-/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu
-FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR
-U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c
-ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR
-FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k
-A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw
-eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl
-sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp
-VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q
-A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+
-ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
-BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD
-ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px
-KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI
-FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv
-oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg
-u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP
-0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf
-3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl
-8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+
-DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN
-PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/
-ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Assured ID Root G2"
-# Serial: 15385348160840213938643033620894905419
-# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d
-# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f
-# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85
------BEGIN CERTIFICATE-----
-MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
-b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG
-EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
-cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi
-MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA
-n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc
-biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp
-EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA
-bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu
-YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB
-AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW
-BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI
-QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I
-0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni
-lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9
-B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv
-ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo
-IhNzbM8m9Yop5w==
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Assured ID Root G3"
-# Serial: 15459312981008553731928384953135426796
-# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb
-# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89
-# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2
------BEGIN CERTIFICATE-----
-MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw
-CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
-ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg
-RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV
-UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
-Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq
-hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf
-Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q
-RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
-BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD
-AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY
-JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv
-6pZjamVFkpUBtA==
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Global Root G2"
-# Serial: 4293743540046975378534879503202253541
-# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44
-# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4
-# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f
------BEGIN CERTIFICATE-----
-MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
-MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT
-MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
-b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG
-9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI
-2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx
-1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ
-q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz
-tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ
-vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP
-BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV
-5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY
-1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4
-NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG
-Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91
-8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe
-pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl
-MrY=
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Global Root G3"
-# Serial: 7089244469030293291760083333884364146
-# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca
-# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e
-# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0
------BEGIN CERTIFICATE-----
-MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw
-CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
-ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe
-Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw
-EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
-IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF
-K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG
-fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO
-Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd
-BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx
-AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/
-oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8
-sycX
------END CERTIFICATE-----
-
-# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
-# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
-# Label: "DigiCert Trusted Root G4"
-# Serial: 7451500558977370777930084869016614236
-# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49
-# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4
-# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88
------BEGIN CERTIFICATE-----
-MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
-RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
-UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
-Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
-ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
-xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
-ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
-DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
-jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
-CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
-EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
-fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
-uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
-chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
-9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
-hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
-ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
-SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
-+SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
-fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
-sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
-cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
-0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
-4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
-r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
-/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
-gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
------END CERTIFICATE-----
-
-# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited
-# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited
-# Label: "COMODO RSA Certification Authority"
-# Serial: 101909084537582093308941363524873193117
-# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18
-# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4
-# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34
------BEGIN CERTIFICATE-----
-MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB
-hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
-A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV
-BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5
-MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT
-EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR
-Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh
-dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR
-6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X
-pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC
-9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV
-/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf
-Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z
-+pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w
-qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah
-SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC
-u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf
-Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq
-crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E
-FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB
-/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl
-wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM
-4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV
-2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna
-FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ
-CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK
-boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke
-jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL
-S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb
-QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl
-0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB
-NVOFBkpdn627G190
------END CERTIFICATE-----
-
-# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
-# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
-# Label: "USERTrust RSA Certification Authority"
-# Serial: 2645093764781058787591871645665788717
-# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5
-# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e
-# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2
------BEGIN CERTIFICATE-----
-MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB
-iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl
-cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV
-BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw
-MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV
-BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU
-aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy
-dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B
-3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY
-tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/
-Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2
-VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT
-79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6
-c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT
-Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l
-c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee
-UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE
-Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd
-BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G
-A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF
-Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO
-VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3
-ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs
-8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR
-iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze
-Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ
-XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/
-qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB
-VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB
-L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG
-jjxDah2nGN59PRbxYvnKkKj9
------END CERTIFICATE-----
-
-# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
-# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
-# Label: "USERTrust ECC Certification Authority"
-# Serial: 123013823720199481456569720443997572134
-# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1
-# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0
-# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a
------BEGIN CERTIFICATE-----
-MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
-MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
-eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
-JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
-MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
-Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
-VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
-aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
-I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
-o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
-A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
-VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
-zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
-RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
-# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
-# Label: "GlobalSign ECC Root CA - R4"
-# Serial: 14367148294922964480859022125800977897474
-# MD5 Fingerprint: 20:f0:27:68:d1:7e:a0:9d:0e:e6:2a:ca:df:5c:89:8e
-# SHA1 Fingerprint: 69:69:56:2e:40:80:f4:24:a1:e7:19:9f:14:ba:f3:ee:58:ab:6a:bb
-# SHA256 Fingerprint: be:c9:49:11:c2:95:56:76:db:6c:0a:55:09:86:d7:6e:3b:a0:05:66:7c:44:2c:97:62:b4:fb:b7:73:de:22:8c
------BEGIN CERTIFICATE-----
-MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk
-MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH
-bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
-DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
-QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ
-FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw
-DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F
-uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX
-kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs
-ewv4n4Q=
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
-# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
-# Label: "GlobalSign ECC Root CA - R5"
-# Serial: 32785792099990507226680698011560947931244
-# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08
-# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa
-# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24
------BEGIN CERTIFICATE-----
-MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk
-MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH
-bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
-DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
-QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
-MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc
-8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke
-hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD
-VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI
-KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg
-515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO
-xwy8p2Fp8fc74SrL+SvzZpA3
------END CERTIFICATE-----
-
-# Issuer: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
-# Subject: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden
-# Label: "Staat der Nederlanden EV Root CA"
-# Serial: 10000013
-# MD5 Fingerprint: fc:06:af:7b:e8:1a:f1:9a:b4:e8:d2:70:1f:c0:f5:ba
-# SHA1 Fingerprint: 76:e2:7e:c1:4f:db:82:c1:c0:a6:75:b5:05:be:3d:29:b4:ed:db:bb
-# SHA256 Fingerprint: 4d:24:91:41:4c:fe:95:67:46:ec:4c:ef:a6:cf:6f:72:e2:8a:13:29:43:2f:9d:8a:90:7a:c4:cb:5d:ad:c1:5a
------BEGIN CERTIFICATE-----
-MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO
-TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh
-dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y
-MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg
-TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS
-b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS
-M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC
-UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d
-Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p
-rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l
-pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb
-j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC
-KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS
-/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X
-cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH
-1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP
-px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB
-/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7
-MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI
-eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u
-2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS
-v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC
-wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy
-CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e
-vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6
-Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa
-Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL
-eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8
-FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc
-7uzXLg==
------END CERTIFICATE-----
-
-# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
-# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
-# Label: "IdenTrust Commercial Root CA 1"
-# Serial: 13298821034946342390520003877796839426
-# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7
-# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25
-# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae
------BEGIN CERTIFICATE-----
-MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK
-MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu
-VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw
-MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw
-JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT
-3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU
-+ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp
-S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1
-bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi
-T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL
-vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK
-Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK
-dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT
-c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv
-l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N
-iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
-/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD
-ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH
-6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt
-LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93
-nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3
-+wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK
-W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT
-AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq
-l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG
-4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ
-mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A
-7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H
------END CERTIFICATE-----
-
-# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
-# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
-# Label: "IdenTrust Public Sector Root CA 1"
-# Serial: 13298821034946342390521976156843933698
-# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba
-# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd
-# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f
------BEGIN CERTIFICATE-----
-MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN
-MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu
-VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN
-MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0
-MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi
-MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7
-ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy
-RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS
-bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF
-/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R
-3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw
-EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy
-9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V
-GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ
-2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV
-WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD
-W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
-BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN
-AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj
-t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV
-DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9
-TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G
-lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW
-mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df
-WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5
-+bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ
-tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA
-GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv
-8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c
------END CERTIFICATE-----
-
-# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
-# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
-# Label: "Entrust Root Certification Authority - G2"
-# Serial: 1246989352
-# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2
-# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4
-# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39
------BEGIN CERTIFICATE-----
-MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC
-VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50
-cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs
-IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz
-dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy
-NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu
-dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt
-dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0
-aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj
-YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
-AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T
-RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN
-cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW
-wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1
-U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0
-jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP
-BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN
-BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/
-jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ
-Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v
-1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R
-nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH
-VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g==
------END CERTIFICATE-----
-
-# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
-# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
-# Label: "Entrust Root Certification Authority - EC1"
-# Serial: 51543124481930649114116133369
-# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc
-# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47
-# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5
------BEGIN CERTIFICATE-----
-MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG
-A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
-d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
-dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq
-RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy
-MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD
-VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0
-L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g
-Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD
-ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi
-A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt
-ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH
-Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
-BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC
-R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX
-hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G
------END CERTIFICATE-----
-
-# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority
-# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority
-# Label: "CFCA EV ROOT"
-# Serial: 407555286
-# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30
-# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83
-# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd
------BEGIN CERTIFICATE-----
-MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD
-TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
-aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx
-MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j
-aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP
-T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03
-sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL
-TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5
-/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp
-7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz
-EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt
-hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP
-a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot
-aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg
-TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV
-PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv
-cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL
-tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd
-BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB
-ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT
-ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL
-jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS
-ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy
-P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19
-xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d
-Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN
-5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe
-/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z
-AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
-5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
------END CERTIFICATE-----
-
-# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
-# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
-# Label: "OISTE WISeKey Global Root GB CA"
-# Serial: 157768595616588414422159278966750757568
-# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d
-# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed
-# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6
------BEGIN CERTIFICATE-----
-MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt
-MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg
-Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i
-YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x
-CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG
-b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh
-bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3
-HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx
-WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX
-1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk
-u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P
-99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r
-M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
-AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB
-BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh
-cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5
-gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO
-ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf
-aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic
-Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM=
------END CERTIFICATE-----
-
-# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
-# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
-# Label: "SZAFIR ROOT CA2"
-# Serial: 357043034767186914217277344587386743377558296292
-# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99
-# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de
-# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe
------BEGIN CERTIFICATE-----
-MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL
-BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6
-ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw
-NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L
-cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg
-Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN
-QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT
-3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw
-3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6
-3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5
-BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN
-XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
-AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF
-AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw
-8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG
-nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP
-oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy
-d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg
-LvWpCz/UXeHPhJ/iGcJfitYgHuNztw==
------END CERTIFICATE-----
-
-# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
-# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
-# Label: "Certum Trusted Network CA 2"
-# Serial: 44979900017204383099463764357512596969
-# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2
-# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92
-# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04
------BEGIN CERTIFICATE-----
-MIIF0jCCA7qgAwIBAgIQIdbQSk8lD8kyN/yqXhKN6TANBgkqhkiG9w0BAQ0FADCB
-gDELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVjaG5vbG9naWVzIFMu
-QS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEkMCIG
-A1UEAxMbQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQSAyMCIYDzIwMTExMDA2MDgz
-OTU2WhgPMjA0NjEwMDYwODM5NTZaMIGAMQswCQYDVQQGEwJQTDEiMCAGA1UEChMZ
-VW5pemV0byBUZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRp
-ZmljYXRpb24gQXV0aG9yaXR5MSQwIgYDVQQDExtDZXJ0dW0gVHJ1c3RlZCBOZXR3
-b3JrIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC9+Xj45tWA
-DGSdhhuWZGc/IjoedQF97/tcZ4zJzFxrqZHmuULlIEub2pt7uZld2ZuAS9eEQCsn
-0+i6MLs+CRqnSZXvK0AkwpfHp+6bJe+oCgCXhVqqndwpyeI1B+twTUrWwbNWuKFB
-OJvR+zF/j+Bf4bE/D44WSWDXBo0Y+aomEKsq09DRZ40bRr5HMNUuctHFY9rnY3lE
-fktjJImGLjQ/KUxSiyqnwOKRKIm5wFv5HdnnJ63/mgKXwcZQkpsCLL2puTRZCr+E
-Sv/f/rOf69me4Jgj7KZrdxYq28ytOxykh9xGc14ZYmhFV+SQgkK7QtbwYeDBoz1m
-o130GO6IyY0XRSmZMnUCMe4pJshrAua1YkV/NxVaI2iJ1D7eTiew8EAMvE0Xy02i
-sx7QBlrd9pPPV3WZ9fqGGmd4s7+W/jTcvedSVuWz5XV710GRBdxdaeOVDUO5/IOW
-OZV7bIBaTxNyxtd9KXpEulKkKtVBRgkg/iKgtlswjbyJDNXXcPiHUv3a76xRLgez
-Tv7QCdpw75j6VuZt27VXS9zlLCUVyJ4ueE742pyehizKV/Ma5ciSixqClnrDvFAS
-adgOWkaLOusm+iPJtrCBvkIApPjW/jAux9JG9uWOdf3yzLnQh1vMBhBgu4M1t15n
-3kfsmUjxpKEV/q2MYo45VU85FrmxY53/twIDAQABo0IwQDAPBgNVHRMBAf8EBTAD
-AQH/MB0GA1UdDgQWBBS2oVQ5AsOgP46KvPrU+Bym0ToO/TAOBgNVHQ8BAf8EBAMC
-AQYwDQYJKoZIhvcNAQENBQADggIBAHGlDs7k6b8/ONWJWsQCYftMxRQXLYtPU2sQ
-F/xlhMcQSZDe28cmk4gmb3DWAl45oPePq5a1pRNcgRRtDoGCERuKTsZPpd1iHkTf
-CVn0W3cLN+mLIMb4Ck4uWBzrM9DPhmDJ2vuAL55MYIR4PSFk1vtBHxgP58l1cb29
-XN40hz5BsA72udY/CROWFC/emh1auVbONTqwX3BNXuMp8SMoclm2q8KMZiYcdywm
-djWLKKdpoPk79SPdhRB0yZADVpHnr7pH1BKXESLjokmUbOe3lEu6LaTaM4tMpkT/
-WjzGHWTYtTHkpjx6qFcL2+1hGsvxznN3Y6SHb0xRONbkX8eftoEq5IVIeVheO/jb
-AoJnwTnbw3RLPTYe+SmTiGhbqEQZIfCn6IENLOiTNrQ3ssqwGyZ6miUfmpqAnksq
-P/ujmv5zMnHCnsZy4YpoJ/HkD7TETKVhk/iXEAcqMCWpuchxuO9ozC1+9eB+D4Ko
-b7a6bINDd82Kkhehnlt4Fj1F4jNy3eFmypnTycUm/Q1oBEauttmbjL4ZvrHG8hnj
-XALKLNhvSgfZyTXaQHXyxKcZb55CEJh15pWLYLztxRLXis7VmFxWlgPF7ncGNf/P
-5O4/E2Hu29othfDNrp2yGAlFw5Khchf8R7agCyzxxN5DaAhqXzvwdmP7zAYspsbi
-DrW5viSP
------END CERTIFICATE-----
-
-# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
-# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
-# Label: "Hellenic Academic and Research Institutions RootCA 2015"
-# Serial: 0
-# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce
-# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6
-# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36
------BEGIN CERTIFICATE-----
-MIIGCzCCA/OgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBpjELMAkGA1UEBhMCR1Ix
-DzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5k
-IFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxQDA+BgNVBAMT
-N0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgUm9v
-dENBIDIwMTUwHhcNMTUwNzA3MTAxMTIxWhcNNDAwNjMwMTAxMTIxWjCBpjELMAkG
-A1UEBhMCR1IxDzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNh
-ZGVtaWMgYW5kIFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkx
-QDA+BgNVBAMTN0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1
-dGlvbnMgUm9vdENBIDIwMTUwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC
-AQDC+Kk/G4n8PDwEXT2QNrCROnk8ZlrvbTkBSRq0t89/TSNTt5AA4xMqKKYx8ZEA
-4yjsriFBzh/a/X0SWwGDD7mwX5nh8hKDgE0GPt+sr+ehiGsxr/CL0BgzuNtFajT0
-AoAkKAoCFZVedioNmToUW/bLy1O8E00BiDeUJRtCvCLYjqOWXjrZMts+6PAQZe10
-4S+nfK8nNLspfZu2zwnI5dMK/IhlZXQK3HMcXM1AsRzUtoSMTFDPaI6oWa7CJ06C
-ojXdFPQf/7J31Ycvqm59JCfnxssm5uX+Zwdj2EUN3TpZZTlYepKZcj2chF6IIbjV
-9Cz82XBST3i4vTwri5WY9bPRaM8gFH5MXF/ni+X1NYEZN9cRCLdmvtNKzoNXADrD
-gfgXy5I2XdGj2HUb4Ysn6npIQf1FGQatJ5lOwXBH3bWfgVMS5bGMSF0xQxfjjMZ6
-Y5ZLKTBOhE5iGV48zpeQpX8B653g+IuJ3SWYPZK2fu/Z8VFRfS0myGlZYeCsargq
-NhEEelC9MoS+L9xy1dcdFkfkR2YgP/SWxa+OAXqlD3pk9Q0Yh9muiNX6hME6wGko
-LfINaFGq46V3xqSQDqE3izEjR8EJCOtu93ib14L8hCCZSRm2Ekax+0VVFqmjZayc
-Bw/qa9wfLgZy7IaIEuQt218FL+TwA9MmM+eAws1CoRc0CwIDAQABo0IwQDAPBgNV
-HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUcRVnyMjJvXVd
-ctA4GGqd83EkVAswDQYJKoZIhvcNAQELBQADggIBAHW7bVRLqhBYRjTyYtcWNl0I
-XtVsyIe9tC5G8jH4fOpCtZMWVdyhDBKg2mF+D1hYc2Ryx+hFjtyp8iY/xnmMsVMI
-M4GwVhO+5lFc2JsKT0ucVlMC6U/2DWDqTUJV6HwbISHTGzrMd/K4kPFox/la/vot
-9L/J9UUbzjgQKjeKeaO04wlshYaT/4mWJ3iBj2fjRnRUjtkNaeJK9E10A/+yd+2V
-Z5fkscWrv2oj6NSU4kQoYsRL4vDY4ilrGnB+JGGTe08DMiUNRSQrlrRGar9KC/ea
-j8GsGsVn82800vpzY4zvFrCopEYq+OsS7HK07/grfoxSwIuEVPkvPuNVqNxmsdnh
-X9izjFk0WaSrT2y7HxjbdavYy5LNlDhhDgcGH0tGEPEVvo2FXDtKK4F5D7Rpn0lQ
-l033DlZdwJVqwjbDG2jJ9SrcR5q+ss7FJej6A7na+RZukYT1HCjI/CbM1xyQVqdf
-bzoEvM14iQuODy+jqk+iGxI9FghAD/FGTNeqewjBCvVtJ94Cj8rDtSvK6evIIVM4
-pcw72Hc3MKJP2W/R8kCtQXoXxdZKNYm3QdV8hn9VTYNKpXMgwDqvkPGaJI7ZjnHK
-e7iG2rKPmT4dEw0SEe7Uq/DpFXYC5ODfqiAeW2GFZECpkJcNrVPSWh2HagCXZWK0
-vm9qp/UsQu0yrbYhnr68
------END CERTIFICATE-----
-
-# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
-# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
-# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015"
-# Serial: 0
-# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef
-# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66
-# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33
------BEGIN CERTIFICATE-----
-MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN
-BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
-c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl
-bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv
-b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ
-BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj
-YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5
-MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0
-dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg
-QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa
-jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC
-MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi
-C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep
-lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
-TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
------END CERTIFICATE-----
-
-# Issuer: CN=ISRG Root X1 O=Internet Security Research Group
-# Subject: CN=ISRG Root X1 O=Internet Security Research Group
-# Label: "ISRG Root X1"
-# Serial: 172886928669790476064670243504169061120
-# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e
-# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8
-# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6
------BEGIN CERTIFICATE-----
-MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
-TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
-cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
-WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
-ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
-MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
-h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
-0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
-A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
-T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
-B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
-B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
-KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
-OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
-jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
-qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
-rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
-HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
-hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
-ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
-3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
-NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
-ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
-TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
-jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
-oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
-4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
-mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
-emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
------END CERTIFICATE-----
-
-# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
-# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
-# Label: "AC RAIZ FNMT-RCM"
-# Serial: 485876308206448804701554682760554759
-# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d
-# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20
-# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa
------BEGIN CERTIFICATE-----
-MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx
-CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ
-WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ
-BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG
-Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/
-yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf
-BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz
-WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF
-tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z
-374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC
-IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL
-mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7
-wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS
-MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2
-ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet
-UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw
-AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H
-YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3
-LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD
-nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1
-RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM
-LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf
-77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N
-JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm
-fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp
-6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp
-1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B
-9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok
-RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv
-uu8wd+RU4riEmViAqhOLUTpPSPaLtrM=
------END CERTIFICATE-----
-
-# Issuer: CN=Amazon Root CA 1 O=Amazon
-# Subject: CN=Amazon Root CA 1 O=Amazon
-# Label: "Amazon Root CA 1"
-# Serial: 143266978916655856878034712317230054538369994
-# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6
-# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16
-# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e
------BEGIN CERTIFICATE-----
-MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
-ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
-b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
-MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
-b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
-ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
-9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
-IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
-VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
-93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
-jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
-AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
-A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
-U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
-N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
-o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
-5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
-rqXRfboQnoZsG4q5WTP468SQvvG5
------END CERTIFICATE-----
-
-# Issuer: CN=Amazon Root CA 2 O=Amazon
-# Subject: CN=Amazon Root CA 2 O=Amazon
-# Label: "Amazon Root CA 2"
-# Serial: 143266982885963551818349160658925006970653239
-# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66
-# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a
-# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4
------BEGIN CERTIFICATE-----
-MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF
-ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
-b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL
-MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
-b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK
-gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ
-W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg
-1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K
-8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r
-2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me
-z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR
-8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj
-mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz
-7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6
-+XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI
-0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB
-Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm
-UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2
-LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY
-+gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS
-k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl
-7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm
-btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl
-urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+
-fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63
-n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE
-76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H
-9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT
-4PsJYGw=
------END CERTIFICATE-----
-
-# Issuer: CN=Amazon Root CA 3 O=Amazon
-# Subject: CN=Amazon Root CA 3 O=Amazon
-# Label: "Amazon Root CA 3"
-# Serial: 143266986699090766294700635381230934788665930
-# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87
-# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e
-# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4
------BEGIN CERTIFICATE-----
-MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
-MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
-Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
-A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
-Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
-ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
-QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
-ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
-BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
-YyRIHN8wfdVoOw==
------END CERTIFICATE-----
-
-# Issuer: CN=Amazon Root CA 4 O=Amazon
-# Subject: CN=Amazon Root CA 4 O=Amazon
-# Label: "Amazon Root CA 4"
-# Serial: 143266989758080763974105200630763877849284878
-# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd
-# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be
-# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92
------BEGIN CERTIFICATE-----
-MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5
-MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
-Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
-A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
-Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi
-9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk
-M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB
-/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB
-MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw
-CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
-1KyLa2tJElMzrdfkviT8tQp21KW8EA==
------END CERTIFICATE-----
-
-# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
-# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
-# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
-# Serial: 1
-# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49
-# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca
-# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16
------BEGIN CERTIFICATE-----
-MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx
-GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp
-bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w
-KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0
-BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy
-dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG
-EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll
-IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU
-QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT
-TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg
-LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7
-a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr
-LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr
-N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X
-YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/
-iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f
-AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH
-V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
-BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh
-AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf
-IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4
-lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c
-8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf
-lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM=
------END CERTIFICATE-----
-
-# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
-# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
-# Label: "GDCA TrustAUTH R5 ROOT"
-# Serial: 9009899650740120186
-# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4
-# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4
-# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93
------BEGIN CERTIFICATE-----
-MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE
-BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ
-IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0
-MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV
-BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w
-HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF
-AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj
-Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj
-TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u
-KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj
-qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm
-MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12
-ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP
-zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk
-L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC
-jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA
-HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC
-AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB
-/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg
-p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm
-DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5
-COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry
-L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf
-JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg
-IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io
-2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV
-09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ
-XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq
-T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe
-MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g==
------END CERTIFICATE-----
-
-# Issuer: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Subject: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Label: "TrustCor RootCert CA-1"
-# Serial: 15752444095811006489
-# MD5 Fingerprint: 6e:85:f1:dc:1a:00:d3:22:d5:b2:b2:ac:6b:37:05:45
-# SHA1 Fingerprint: ff:bd:cd:e7:82:c8:43:5e:3c:6f:26:86:5c:ca:a8:3a:45:5b:c3:0a
-# SHA256 Fingerprint: d4:0e:9c:86:cd:8f:e4:68:c1:77:69:59:f4:9e:a7:74:fa:54:86:84:b6:c4:06:f3:90:92:61:f4:dc:e2:57:5c
------BEGIN CERTIFICATE-----
-MIIEMDCCAxigAwIBAgIJANqb7HHzA7AZMA0GCSqGSIb3DQEBCwUAMIGkMQswCQYD
-VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
-MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
-cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRydXN0Q29y
-IFJvb3RDZXJ0IENBLTEwHhcNMTYwMjA0MTIzMjE2WhcNMjkxMjMxMTcyMzE2WjCB
-pDELMAkGA1UEBhMCUEExDzANBgNVBAgMBlBhbmFtYTEUMBIGA1UEBwwLUGFuYW1h
-IENpdHkxJDAiBgNVBAoMG1RydXN0Q29yIFN5c3RlbXMgUy4gZGUgUi5MLjEnMCUG
-A1UECwweVHJ1c3RDb3IgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MR8wHQYDVQQDDBZU
-cnVzdENvciBSb290Q2VydCBDQS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
-CgKCAQEAv463leLCJhJrMxnHQFgKq1mqjQCj/IDHUHuO1CAmujIS2CNUSSUQIpid
-RtLByZ5OGy4sDjjzGiVoHKZaBeYei0i/mJZ0PmnK6bV4pQa81QBeCQryJ3pS/C3V
-seq0iWEk8xoT26nPUu0MJLq5nux+AHT6k61sKZKuUbS701e/s/OojZz0JEsq1pme
-9J7+wH5COucLlVPat2gOkEz7cD+PSiyU8ybdY2mplNgQTsVHCJCZGxdNuWxu72CV
-EY4hgLW9oHPY0LJ3xEXqWib7ZnZ2+AYfYW0PVcWDtxBWcgYHpfOxGgMFZA6dWorW
-hnAbJN7+KIor0Gqw/Hqi3LJ5DotlDwIDAQABo2MwYTAdBgNVHQ4EFgQU7mtJPHo/
-DeOxCbeKyKsZn3MzUOcwHwYDVR0jBBgwFoAU7mtJPHo/DeOxCbeKyKsZn3MzUOcw
-DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD
-ggEBACUY1JGPE+6PHh0RU9otRCkZoB5rMZ5NDp6tPVxBb5UrJKF5mDo4Nvu7Zp5I
-/5CQ7z3UuJu0h3U/IJvOcs+hVcFNZKIZBqEHMwwLKeXx6quj7LUKdJDHfXLy11yf
-ke+Ri7fc7Waiz45mO7yfOgLgJ90WmMCV1Aqk5IGadZQ1nJBfiDcGrVmVCrDRZ9MZ
-yonnMlo2HD6CqFqTvsbQZJG2z9m2GM/bftJlo6bEjhcxwft+dtvTheNYsnd6djts
-L1Ac59v2Z3kf9YKVmgenFK+P3CghZwnS1k1aHBkcjndcw5QkPTJrS37UeJSDvjdN
-zl/HHk484IkzlQsPpTLWPFp5LBk=
------END CERTIFICATE-----
-
-# Issuer: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Subject: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Label: "TrustCor RootCert CA-2"
-# Serial: 2711694510199101698
-# MD5 Fingerprint: a2:e1:f8:18:0b:ba:45:d5:c7:41:2a:bb:37:52:45:64
-# SHA1 Fingerprint: b8:be:6d:cb:56:f1:55:b9:63:d4:12:ca:4e:06:34:c7:94:b2:1c:c0
-# SHA256 Fingerprint: 07:53:e9:40:37:8c:1b:d5:e3:83:6e:39:5d:ae:a5:cb:83:9e:50:46:f1:bd:0e:ae:19:51:cf:10:fe:c7:c9:65
------BEGIN CERTIFICATE-----
-MIIGLzCCBBegAwIBAgIIJaHfyjPLWQIwDQYJKoZIhvcNAQELBQAwgaQxCzAJBgNV
-BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw
-IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy
-dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEfMB0GA1UEAwwWVHJ1c3RDb3Ig
-Um9vdENlcnQgQ0EtMjAeFw0xNjAyMDQxMjMyMjNaFw0zNDEyMzExNzI2MzlaMIGk
-MQswCQYDVQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEg
-Q2l0eTEkMCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYD
-VQQLDB5UcnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRy
-dXN0Q29yIFJvb3RDZXJ0IENBLTIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQCnIG7CKqJiJJWQdsg4foDSq8GbZQWU9MEKENUCrO2fk8eHyLAnK0IMPQo+
-QVqedd2NyuCb7GgypGmSaIwLgQ5WoD4a3SwlFIIvl9NkRvRUqdw6VC0xK5mC8tkq
-1+9xALgxpL56JAfDQiDyitSSBBtlVkxs1Pu2YVpHI7TYabS3OtB0PAx1oYxOdqHp
-2yqlO/rOsP9+aij9JxzIsekp8VduZLTQwRVtDr4uDkbIXvRR/u8OYzo7cbrPb1nK
-DOObXUm4TOJXsZiKQlecdu/vvdFoqNL0Cbt3Nb4lggjEFixEIFapRBF37120Hape
-az6LMvYHL1cEksr1/p3C6eizjkxLAjHZ5DxIgif3GIJ2SDpxsROhOdUuxTTCHWKF
-3wP+TfSvPd9cW436cOGlfifHhi5qjxLGhF5DUVCcGZt45vz27Ud+ez1m7xMTiF88
-oWP7+ayHNZ/zgp6kPwqcMWmLmaSISo5uZk3vFsQPeSghYA2FFn3XVDjxklb9tTNM
-g9zXEJ9L/cb4Qr26fHMC4P99zVvh1Kxhe1fVSntb1IVYJ12/+CtgrKAmrhQhJ8Z3
-mjOAPF5GP/fDsaOGM8boXg25NSyqRsGFAnWAoOsk+xWq5Gd/bnc/9ASKL3x74xdh
-8N0JqSDIvgmk0H5Ew7IwSjiqqewYmgeCK9u4nBit2uBGF6zPXQIDAQABo2MwYTAd
-BgNVHQ4EFgQU2f4hQG6UnrybPZx9mCAZ5YwwYrIwHwYDVR0jBBgwFoAU2f4hQG6U
-nrybPZx9mCAZ5YwwYrIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYw
-DQYJKoZIhvcNAQELBQADggIBAJ5Fngw7tu/hOsh80QA9z+LqBrWyOrsGS2h60COX
-dKcs8AjYeVrXWoSK2BKaG9l9XE1wxaX5q+WjiYndAfrs3fnpkpfbsEZC89NiqpX+
-MWcUaViQCqoL7jcjx1BRtPV+nuN79+TMQjItSQzL/0kMmx40/W5ulop5A7Zv2wnL
-/V9lFDfhOPXzYRZY5LVtDQsEGz9QLX+zx3oaFoBg+Iof6Rsqxvm6ARppv9JYx1RX
-CI/hOWB3S6xZhBqI8d3LT3jX5+EzLfzuQfogsL7L9ziUwOHQhQ+77Sxzq+3+knYa
-ZH9bDTMJBzN7Bj8RpFxwPIXAz+OQqIN3+tvmxYxoZxBnpVIt8MSZj3+/0WvitUfW
-2dCFmU2Umw9Lje4AWkcdEQOsQRivh7dvDDqPys/cA8GiCcjl/YBeyGBCARsaU1q7
-N6a3vLqE6R5sGtRk2tRD/pOLS/IseRYQ1JMLiI+h2IYURpFHmygk71dSTlxCnKr3
-Sewn6EAes6aJInKc9Q0ztFijMDvd1GpUk74aTfOTlPf8hAs/hCBcNANExdqtvArB
-As8e5ZTZ845b2EzwnexhF7sUMlQMAimTHpKG9n/v55IFDlndmQguLvqcAFLTxWYp
-5KeXRKQOKIETNcX2b2TmQcTVL8w0RSXPQQCWPUouwpaYT05KnJe32x+SMsj/D1Fu
-1uwJ
------END CERTIFICATE-----
-
-# Issuer: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Subject: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority
-# Label: "TrustCor ECA-1"
-# Serial: 9548242946988625984
-# MD5 Fingerprint: 27:92:23:1d:0a:f5:40:7c:e9:e6:6b:9d:d8:f5:e7:6c
-# SHA1 Fingerprint: 58:d1:df:95:95:67:6b:63:c0:f0:5b:1c:17:4d:8b:84:0b:c8:78:bd
-# SHA256 Fingerprint: 5a:88:5d:b1:9c:01:d9:12:c5:75:93:88:93:8c:af:bb:df:03:1a:b2:d4:8e:91:ee:15:58:9b:42:97:1d:03:9c
------BEGIN CERTIFICATE-----
-MIIEIDCCAwigAwIBAgIJAISCLF8cYtBAMA0GCSqGSIb3DQEBCwUAMIGcMQswCQYD
-VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk
-MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U
-cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxFzAVBgNVBAMMDlRydXN0Q29y
-IEVDQS0xMB4XDTE2MDIwNDEyMzIzM1oXDTI5MTIzMTE3MjgwN1owgZwxCzAJBgNV
-BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw
-IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy
-dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEXMBUGA1UEAwwOVHJ1c3RDb3Ig
-RUNBLTEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPj+ARtZ+odnbb
-3w9U73NjKYKtR8aja+3+XzP4Q1HpGjORMRegdMTUpwHmspI+ap3tDvl0mEDTPwOA
-BoJA6LHip1GnHYMma6ve+heRK9jGrB6xnhkB1Zem6g23xFUfJ3zSCNV2HykVh0A5
-3ThFEXXQmqc04L/NyFIduUd+Dbi7xgz2c1cWWn5DkR9VOsZtRASqnKmcp0yJF4Ou
-owReUoCLHhIlERnXDH19MURB6tuvsBzvgdAsxZohmz3tQjtQJvLsznFhBmIhVE5/
-wZ0+fyCMgMsq2JdiyIMzkX2woloPV+g7zPIlstR8L+xNxqE6FXrntl019fZISjZF
-ZtS6mFjBAgMBAAGjYzBhMB0GA1UdDgQWBBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAf
-BgNVHSMEGDAWgBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAPBgNVHRMBAf8EBTADAQH/
-MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAQEABT41XBVwm8nHc2Fv
-civUwo/yQ10CzsSUuZQRg2dd4mdsdXa/uwyqNsatR5Nj3B5+1t4u/ukZMjgDfxT2
-AHMsWbEhBuH7rBiVDKP/mZb3Kyeb1STMHd3BOuCYRLDE5D53sXOpZCz2HAF8P11F
-hcCF5yWPldwX8zyfGm6wyuMdKulMY/okYWLW2n62HGz1Ah3UKt1VkOsqEUc8Ll50
-soIipX1TH0XsJ5F95yIW6MBoNtjG8U+ARDL54dHRHareqKucBK+tIA5kmE2la8BI
-WJZpTdwHjFGTot+fDz2LYLSCjaoITmJF4PkL0uDgPFveXHEnJcLmA4GLEFPjx1Wi
-tJ/X5g==
------END CERTIFICATE-----
-
-# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
-# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
-# Label: "SSL.com Root Certification Authority RSA"
-# Serial: 8875640296558310041
-# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29
-# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb
-# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69
------BEGIN CERTIFICATE-----
-MIIF3TCCA8WgAwIBAgIIeyyb0xaAMpkwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UE
-BhMCVVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQK
-DA9TU0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZp
-Y2F0aW9uIEF1dGhvcml0eSBSU0EwHhcNMTYwMjEyMTczOTM5WhcNNDEwMjEyMTcz
-OTM5WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
-dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNv
-bSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFJTQTCCAiIwDQYJKoZIhvcN
-AQEBBQADggIPADCCAgoCggIBAPkP3aMrfcvQKv7sZ4Wm5y4bunfh4/WvpOz6Sl2R
-xFdHaxh3a3by/ZPkPQ/CFp4LZsNWlJ4Xg4XOVu/yFv0AYvUiCVToZRdOQbngT0aX
-qhvIuG5iXmmxX9sqAn78bMrzQdjt0Oj8P2FI7bADFB0QDksZ4LtO7IZl/zbzXmcC
-C52GVWH9ejjt/uIZALdvoVBidXQ8oPrIJZK0bnoix/geoeOy3ZExqysdBP+lSgQ3
-6YWkMyv94tZVNHwZpEpox7Ko07fKoZOI68GXvIz5HdkihCR0xwQ9aqkpk8zruFvh
-/l8lqjRYyMEjVJ0bmBHDOJx+PYZspQ9AhnwC9FwCTyjLrnGfDzrIM/4RJTXq/LrF
-YD3ZfBjVsqnTdXgDciLKOsMf7yzlLqn6niy2UUb9rwPW6mBo6oUWNmuF6R7As93E
-JNyAKoFBbZQ+yODJgUEAnl6/f8UImKIYLEJAs/lvOCdLToD0PYFH4Ih86hzOtXVc
-US4cK38acijnALXRdMbX5J+tB5O2UzU1/Dfkw/ZdFr4hc96SCvigY2q8lpJqPvi8
-ZVWb3vUNiSYE/CUapiVpy8JtynziWV+XrOvvLsi81xtZPCvM8hnIk2snYxnP/Okm
-+Mpxm3+T/jRnhE6Z6/yzeAkzcLpmpnbtG3PrGqUNxCITIJRWCk4sbE6x/c+cCbqi
-M+2HAgMBAAGjYzBhMB0GA1UdDgQWBBTdBAkHovV6fVJTEpKV7jiAJQ2mWTAPBgNV
-HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFN0ECQei9Xp9UlMSkpXuOIAlDaZZMA4G
-A1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAIBgRlCn7Jp0cHh5wYfGV
-cpNxJK1ok1iOMq8bs3AD/CUrdIWQPXhq9LmLpZc7tRiRux6n+UBbkflVma8eEdBc
-Hadm47GUBwwyOabqG7B52B2ccETjit3E+ZUfijhDPwGFpUenPUayvOUiaPd7nNgs
-PgohyC0zrL/FgZkxdMF1ccW+sfAjRfSda/wZY52jvATGGAslu1OJD7OAUN5F7kR/
-q5R4ZJjT9ijdh9hwZXT7DrkT66cPYakylszeu+1jTBi7qUD3oFRuIIhxdRjqerQ0
-cuAjJ3dctpDqhiVAq+8zD8ufgr6iIPv2tS0a5sKFsXQP+8hlAqRSAUfdSSLBv9jr
-a6x+3uxjMxW3IwiPxg+NQVrdjsW5j+VFP3jbutIbQLH+cU0/4IGiul607BXgk90I
-H37hVZkLId6Tngr75qNJvTYw/ud3sqB1l7UtgYgXZSD32pAAn8lSzDLKNXz1PQ/Y
-K9f1JmzJBjSWFupwWRoyeXkLtoh/D1JIPb9s2KJELtFOt3JY04kTlf5Eq/jXixtu
-nLwsoFvVagCvXzfh1foQC5ichucmj87w7G6KVwuA406ywKBjYZC6VWg3dGq2ktuf
-oYYitmUnDuy2n0Jg5GfCtdpBC8TTi2EbvPofkSvXRAdeuims2cXp71NIWuuA8ShY
-Ic2wBlX7Jz9TkHCpBB5XJ7k=
------END CERTIFICATE-----
-
-# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
-# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
-# Label: "SSL.com Root Certification Authority ECC"
-# Serial: 8495723813297216424
-# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e
-# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a
-# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65
------BEGIN CERTIFICATE-----
-MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC
-VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
-U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0
-aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz
-WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0
-b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS
-b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB
-BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI
-7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg
-CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud
-EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD
-VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T
-kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+
-gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl
------END CERTIFICATE-----
-
-# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
-# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
-# Label: "SSL.com EV Root Certification Authority RSA R2"
-# Serial: 6248227494352943350
-# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95
-# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a
-# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c
------BEGIN CERTIFICATE-----
-MIIF6zCCA9OgAwIBAgIIVrYpzTS8ePYwDQYJKoZIhvcNAQELBQAwgYIxCzAJBgNV
-BAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4GA1UEBwwHSG91c3RvbjEYMBYGA1UE
-CgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQDDC5TU0wuY29tIEVWIFJvb3QgQ2Vy
-dGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIyMB4XDTE3MDUzMTE4MTQzN1oXDTQy
-MDUzMDE4MTQzN1owgYIxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4G
-A1UEBwwHSG91c3RvbjEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQD
-DC5TU0wuY29tIEVWIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIy
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAjzZlQOHWTcDXtOlG2mvq
-M0fNTPl9fb69LT3w23jhhqXZuglXaO1XPqDQCEGD5yhBJB/jchXQARr7XnAjssuf
-OePPxU7Gkm0mxnu7s9onnQqG6YE3Bf7wcXHswxzpY6IXFJ3vG2fThVUCAtZJycxa
-4bH3bzKfydQ7iEGonL3Lq9ttewkfokxykNorCPzPPFTOZw+oz12WGQvE43LrrdF9
-HSfvkusQv1vrO6/PgN3B0pYEW3p+pKk8OHakYo6gOV7qd89dAFmPZiw+B6KjBSYR
-aZfqhbcPlgtLyEDhULouisv3D5oi53+aNxPN8k0TayHRwMwi8qFG9kRpnMphNQcA
-b9ZhCBHqurj26bNg5U257J8UZslXWNvNh2n4ioYSA0e/ZhN2rHd9NCSFg83XqpyQ
-Gp8hLH94t2S42Oim9HizVcuE0jLEeK6jj2HdzghTreyI/BXkmg3mnxp3zkyPuBQV
-PWKchjgGAGYS5Fl2WlPAApiiECtoRHuOec4zSnaqW4EWG7WK2NAAe15itAnWhmMO
-pgWVSbooi4iTsjQc2KRVbrcc0N6ZVTsj9CLg+SlmJuwgUHfbSguPvuUCYHBBXtSu
-UDkiFCbLsjtzdFVHB3mBOagwE0TlBIqulhMlQg+5U8Sb/M3kHN48+qvWBkofZ6aY
-MBzdLNvcGJVXZsb/XItW9XcCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAfBgNV
-HSMEGDAWgBT5YLvU49U09rj1BoAlp3PbRmmonjAdBgNVHQ4EFgQU+WC71OPVNPa4
-9QaAJadz20ZpqJ4wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQBW
-s47LCp1Jjr+kxJG7ZhcFUZh1++VQLHqe8RT6q9OKPv+RKY9ji9i0qVQBDb6Thi/5
-Sm3HXvVX+cpVHBK+Rw82xd9qt9t1wkclf7nxY/hoLVUE0fKNsKTPvDxeH3jnpaAg
-cLAExbf3cqfeIg29MyVGjGSSJuM+LmOW2puMPfgYCdcDzH2GguDKBAdRUNf/ktUM
-79qGn5nX67evaOI5JpS6aLe/g9Pqemc9YmeuJeVy6OLk7K4S9ksrPJ/psEDzOFSz
-/bdoyNrGj1E8svuR3Bznm53htw1yj+KkxKl4+esUrMZDBcJlOSgYAsOCsp0FvmXt
-ll9ldDz7CTUue5wT/RsPXcdtgTpWD8w74a8CLyKsRspGPKAcTNZEtF4uXBVmCeEm
-Kf7GUmG6sXP/wwyc5WxqlD8UykAWlYTzWamsX0xhk23RO8yilQwipmdnRC652dKK
-QbNmC1r7fSOl8hqw/96bg5Qu0T/fkreRrwU7ZcegbLHNYhLDkBvjJc40vG93drEQ
-w/cFGsDWr3RiSBd3kmmQYRzelYB0VI8YHMPzA9C/pEN1hlMYegouCRw2n5H9gooi
-S9EOUCXdywMMF8mDAAhONU2Ki+3wApRmLER/y5UnlhetCTCstnEXbosX9hwJ1C07
-mKVx01QT2WDz9UtmT/rx7iASjbSsV7FFY6GsdqnC+w==
------END CERTIFICATE-----
-
-# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
-# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
-# Label: "SSL.com EV Root Certification Authority ECC"
-# Serial: 3182246526754555285
-# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90
-# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d
-# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8
------BEGIN CERTIFICATE-----
-MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC
-VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
-U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp
-Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx
-NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
-dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv
-bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49
-AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA
-VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku
-WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP
-MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
-5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ
-ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
-h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
-# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
-# Label: "GlobalSign Root CA - R6"
-# Serial: 1417766617973444989252670301619537
-# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
-# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
-# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
------BEGIN CERTIFICATE-----
-MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
-MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
-bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
-MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
-MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
-KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
-xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
-ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
-aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
-LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
-1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
-k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
-SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
-bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
-WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
-rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
-MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
-AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
-bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
-nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
-Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
-55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
-vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
-cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
-oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
-nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
-pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
-JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
-8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
-5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
------END CERTIFICATE-----
-
-# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
-# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
-# Label: "OISTE WISeKey Global Root GC CA"
-# Serial: 44084345621038548146064804565436152554
-# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
-# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
-# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
------BEGIN CERTIFICATE-----
-MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
-CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
-bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
-Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
-BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
-ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
-b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
-eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
-p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
-BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
-rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
-57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
-Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
------END CERTIFICATE-----
-
-# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
-# Subject: CN=GTS Root R1 O=Google Trust Services LLC
-# Label: "GTS Root R1"
-# Serial: 146587175971765017618439757810265552097
-# MD5 Fingerprint: 82:1a:ef:d4:d2:4a:f2:9f:e2:3d:97:06:14:70:72:85
-# SHA1 Fingerprint: e1:c9:50:e6:ef:22:f8:4c:56:45:72:8b:92:20:60:d7:d5:a7:a3:e8
-# SHA256 Fingerprint: 2a:57:54:71:e3:13:40:bc:21:58:1c:bd:2c:f1:3e:15:84:63:20:3e:ce:94:bc:f9:d3:cc:19:6b:f0:9a:54:72
------BEGIN CERTIFICATE-----
-MIIFWjCCA0KgAwIBAgIQbkepxUtHDA3sM9CJuRz04TANBgkqhkiG9w0BAQwFADBH
-MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
-QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
-MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
-cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEB
-AQUAA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaM
-f/vo27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vX
-mX7wCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7
-zUjwTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0P
-fyblqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtc
-vfaHszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4
-Zor8Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUsp
-zBmkMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOO
-Rc92wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYW
-k70paDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+
-DVrNVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgF
-lQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
-HQ4EFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBADiW
-Cu49tJYeX++dnAsznyvgyv3SjgofQXSlfKqE1OXyHuY3UjKcC9FhHb8owbZEKTV1
-d5iyfNm9dKyKaOOpMQkpAWBz40d8U6iQSifvS9efk+eCNs6aaAyC58/UEBZvXw6Z
-XPYfcX3v73svfuo21pdwCxXu11xWajOl40k4DLh9+42FpLFZXvRq4d2h9mREruZR
-gyFmxhE+885H7pwoHyXa/6xmld01D1zvICxi/ZG6qcz8WpyTgYMpl0p8WnK0OdC3
-d8t5/Wk6kjftbjhlRn7pYL15iJdfOBL07q9bgsiG1eGZbYwE8na6SfZu6W0eX6Dv
-J4J2QPim01hcDyxC2kLGe4g0x8HYRZvBPsVhHdljUEn2NIVq4BjFbkerQUIpm/Zg
-DdIx02OYI5NaAIFItO/Nis3Jz5nu2Z6qNuFoS3FJFDYoOj0dzpqPJeaAcWErtXvM
-+SUWgeExX6GjfhaknBZqlxi9dnKlC54dNuYvoS++cJEPqOba+MSSQGwlfnuzCdyy
-F62ARPBopY+Udf90WuioAnwMCeKpSwughQtiue+hMZL77/ZRBIls6Kl0obsXs7X9
-SQ98POyDGCBDTtWTurQ0sR8WNh8M5mQ5Fkzc4P4dyKliPUDqysU0ArSuiYgzNdws
-E3PYJ/HQcu51OyLemGhmW/HGY0dVHLqlCFF1pkgl
------END CERTIFICATE-----
-
-# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
-# Subject: CN=GTS Root R2 O=Google Trust Services LLC
-# Label: "GTS Root R2"
-# Serial: 146587176055767053814479386953112547951
-# MD5 Fingerprint: 44:ed:9a:0e:a4:09:3b:00:f2:ae:4c:a3:c6:61:b0:8b
-# SHA1 Fingerprint: d2:73:96:2a:2a:5e:39:9f:73:3f:e1:c7:1e:64:3f:03:38:34:fc:4d
-# SHA256 Fingerprint: c4:5d:7b:b0:8e:6d:67:e6:2e:42:35:11:0b:56:4e:5f:78:fd:92:ef:05:8c:84:0a:ea:4e:64:55:d7:58:5c:60
------BEGIN CERTIFICATE-----
-MIIFWjCCA0KgAwIBAgIQbkepxlqz5yDFMJo/aFLybzANBgkqhkiG9w0BAQwFADBH
-MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
-QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
-MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
-cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEB
-AQUAA4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3Lv
-CvptnfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3Kg
-GjSY6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9Bu
-XvAuMC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOd
-re7kRXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXu
-PuWgf9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1
-mKPV+3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K
-8YzodDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqj
-x5RWIr9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsR
-nTKaG73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0
-kzCqgc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9Ok
-twIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
-HQ4EFgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBALZp
-8KZ3/p7uC4Gt4cCpx/k1HUCCq+YEtN/L9x0Pg/B+E02NjO7jMyLDOfxA325BS0JT
-vhaI8dI4XsRomRyYUpOM52jtG2pzegVATX9lO9ZY8c6DR2Dj/5epnGB3GFW1fgiT
-z9D2PGcDFWEJ+YF59exTpJ/JjwGLc8R3dtyDovUMSRqodt6Sm2T4syzFJ9MHwAiA
-pJiS4wGWAqoC7o87xdFtCjMwc3i5T1QWvwsHoaRc5svJXISPD+AVdyx+Jn7axEvb
-pxZ3B7DNdehyQtaVhJ2Gg/LkkM0JR9SLA3DaWsYDQvTtN6LwG1BUSw7YhN4ZKJmB
-R64JGz9I0cNv4rBgF/XuIwKl2gBbbZCr7qLpGzvpx0QnRY5rn/WkhLx3+WuXrD5R
-RaIRpsyF7gpo8j5QOHokYh4XIDdtak23CZvJ/KRY9bb7nE4Yu5UC56GtmwfuNmsk
-0jmGwZODUNKBRqhfYlcsu2xkiAhu7xNUX90txGdj08+JN7+dIPT7eoOboB6BAFDC
-5AwiWVIQ7UNWhwD4FFKnHYuTjKJNRn8nxnGbJN7k2oaLDX5rIMHAnuFl2GqjpuiF
-izoHCBy69Y9Vmhh1fuXsgWbRIXOhNUQLgD1bnF5vKheW0YMjiGZt5obicDIvUiLn
-yOd/xCxgXS/Dr55FBcOEArf9LAhST4Ldo/DUhgkC
------END CERTIFICATE-----
-
-# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
-# Subject: CN=GTS Root R3 O=Google Trust Services LLC
-# Label: "GTS Root R3"
-# Serial: 146587176140553309517047991083707763997
-# MD5 Fingerprint: 1a:79:5b:6b:04:52:9c:5d:c7:74:33:1b:25:9a:f9:25
-# SHA1 Fingerprint: 30:d4:24:6f:07:ff:db:91:89:8a:0b:e9:49:66:11:eb:8c:5e:46:e5
-# SHA256 Fingerprint: 15:d5:b8:77:46:19:ea:7d:54:ce:1c:a6:d0:b0:c4:03:e0:37:a9:17:f1:31:e8:a0:4e:1e:6b:7a:71:ba:bc:e5
------BEGIN CERTIFICATE-----
-MIICDDCCAZGgAwIBAgIQbkepx2ypcyRAiQ8DVd2NHTAKBggqhkjOPQQDAzBHMQsw
-CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
-MBIGA1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
-MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
-Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQA
-IgNiAAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout
-736GjOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2A
-DDL24CejQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
-DgQWBBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEAgFuk
-fCPAlaUs3L6JbyO5o91lAFJekazInXJ0glMLfalAvWhgxeG4VDvBNhcl2MG9AjEA
-njWSdIUlUfUk7GRSJFClH9voy8l27OyCbvWFGFPouOOaKaqW04MjyaR7YbPMAuhd
------END CERTIFICATE-----
-
-# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
-# Subject: CN=GTS Root R4 O=Google Trust Services LLC
-# Label: "GTS Root R4"
-# Serial: 146587176229350439916519468929765261721
-# MD5 Fingerprint: 5d:b6:6a:c4:60:17:24:6a:1a:99:a8:4b:ee:5e:b4:26
-# SHA1 Fingerprint: 2a:1d:60:27:d9:4a:b1:0a:1c:4d:91:5c:cd:33:a0:cb:3e:2d:54:cb
-# SHA256 Fingerprint: 71:cc:a5:39:1f:9e:79:4b:04:80:25:30:b3:63:e1:21:da:8a:30:43:bb:26:66:2f:ea:4d:ca:7f:c9:51:a4:bd
------BEGIN CERTIFICATE-----
-MIICCjCCAZGgAwIBAgIQbkepyIuUtui7OyrYorLBmTAKBggqhkjOPQQDAzBHMQsw
-CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
-MBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
-MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
-Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQA
-IgNiAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzu
-hXyiQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/l
-xKvRHYqjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
-DgQWBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNnADBkAjBqUFJ0
-CMRw3J5QdCHojXohw0+WbhXRIjVhLfoIN+4Zba3bssx9BzT1YBkstTTZbyACMANx
-sbqjYAuG7ZoIapVon+Kz4ZNkfF6Tpt95LY2F45TPI11xzPKwTdb+mciUqXWi4w==
------END CERTIFICATE-----
-
-# Issuer: CN=UCA Global G2 Root O=UniTrust
-# Subject: CN=UCA Global G2 Root O=UniTrust
-# Label: "UCA Global G2 Root"
-# Serial: 124779693093741543919145257850076631279
-# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
-# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
-# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
------BEGIN CERTIFICATE-----
-MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
-MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
-bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
-CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
-b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
-b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
-kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
-VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
-VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
-C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
-tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
-D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
-j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
-NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
-iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
-O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
-BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
-ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
-L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
-1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
-1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
-b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
-PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
-y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
-EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
-DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
-+Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
-YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
-UB+K+wb1whnw0A==
------END CERTIFICATE-----
-
-# Issuer: CN=UCA Extended Validation Root O=UniTrust
-# Subject: CN=UCA Extended Validation Root O=UniTrust
-# Label: "UCA Extended Validation Root"
-# Serial: 106100277556486529736699587978573607008
-# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
-# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
-# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
------BEGIN CERTIFICATE-----
-MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
-MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
-eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
-MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
-BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
-AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
-D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
-sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
-O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
-sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
-c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
-VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
-KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
-TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
-sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
-1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
-fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
-AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
-l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
-ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
-VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
-c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
-4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
-t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
-2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
-vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
-xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
-cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
-fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
------END CERTIFICATE-----
-
-# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
-# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
-# Label: "Certigna Root CA"
-# Serial: 269714418870597844693661054334862075617
-# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
-# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
-# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
------BEGIN CERTIFICATE-----
-MIIGWzCCBEOgAwIBAgIRAMrpG4nxVQMNo+ZBbcTjpuEwDQYJKoZIhvcNAQELBQAw
-WjELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCURoaW15b3RpczEcMBoGA1UECwwTMDAw
-MiA0ODE0NjMwODEwMDAzNjEZMBcGA1UEAwwQQ2VydGlnbmEgUm9vdCBDQTAeFw0x
-MzEwMDEwODMyMjdaFw0zMzEwMDEwODMyMjdaMFoxCzAJBgNVBAYTAkZSMRIwEAYD
-VQQKDAlEaGlteW90aXMxHDAaBgNVBAsMEzAwMDIgNDgxNDYzMDgxMDAwMzYxGTAX
-BgNVBAMMEENlcnRpZ25hIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw
-ggIKAoICAQDNGDllGlmx6mQWDoyUJJV8g9PFOSbcDO8WV43X2KyjQn+Cyu3NW9sO
-ty3tRQgXstmzy9YXUnIo245Onoq2C/mehJpNdt4iKVzSs9IGPjA5qXSjklYcoW9M
-CiBtnyN6tMbaLOQdLNyzKNAT8kxOAkmhVECe5uUFoC2EyP+YbNDrihqECB63aCPu
-I9Vwzm1RaRDuoXrC0SIxwoKF0vJVdlB8JXrJhFwLrN1CTivngqIkicuQstDuI7pm
-TLtipPlTWmR7fJj6o0ieD5Wupxj0auwuA0Wv8HT4Ks16XdG+RCYyKfHx9WzMfgIh
-C59vpD++nVPiz32pLHxYGpfhPTc3GGYo0kDFUYqMwy3OU4gkWGQwFsWq4NYKpkDf
-ePb1BHxpE4S80dGnBs8B92jAqFe7OmGtBIyT46388NtEbVncSVmurJqZNjBBe3Yz
-IoejwpKGbvlw7q6Hh5UbxHq9MfPU0uWZ/75I7HX1eBYdpnDBfzwboZL7z8g81sWT
-Co/1VTp2lc5ZmIoJlXcymoO6LAQ6l73UL77XbJuiyn1tJslV1c/DeVIICZkHJC1k
-JWumIWmbat10TWuXekG9qxf5kBdIjzb5LdXF2+6qhUVB+s06RbFo5jZMm5BX7CO5
-hwjCxAnxl4YqKE3idMDaxIzb3+KhF1nOJFl0Mdp//TBt2dzhauH8XwIDAQABo4IB
-GjCCARYwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
-FBiHVuBud+4kNTxOc5of1uHieX4rMB8GA1UdIwQYMBaAFBiHVuBud+4kNTxOc5of
-1uHieX4rMEQGA1UdIAQ9MDswOQYEVR0gADAxMC8GCCsGAQUFBwIBFiNodHRwczov
-L3d3d3cuY2VydGlnbmEuZnIvYXV0b3JpdGVzLzBtBgNVHR8EZjBkMC+gLaArhilo
-dHRwOi8vY3JsLmNlcnRpZ25hLmZyL2NlcnRpZ25hcm9vdGNhLmNybDAxoC+gLYYr
-aHR0cDovL2NybC5kaGlteW90aXMuY29tL2NlcnRpZ25hcm9vdGNhLmNybDANBgkq
-hkiG9w0BAQsFAAOCAgEAlLieT/DjlQgi581oQfccVdV8AOItOoldaDgvUSILSo3L
-6btdPrtcPbEo/uRTVRPPoZAbAh1fZkYJMyjhDSSXcNMQH+pkV5a7XdrnxIxPTGRG
-HVyH41neQtGbqH6mid2PHMkwgu07nM3A6RngatgCdTer9zQoKJHyBApPNeNgJgH6
-0BGM+RFq7q89w1DTj18zeTyGqHNFkIwgtnJzFyO+B2XleJINugHA64wcZr+shncB
-lA2c5uk5jR+mUYyZDDl34bSb+hxnV29qao6pK0xXeXpXIs/NX2NGjVxZOob4Mkdi
-o2cNGJHc+6Zr9UhhcyNZjgKnvETq9Emd8VRY+WCv2hikLyhF3HqgiIZd8zvn/yk1
-gPxkQ5Tm4xxvvq0OKmOZK8l+hfZx6AYDlf7ej0gcWtSS6Cvu5zHbugRqh5jnxV/v
-faci9wHYTfmJ0A6aBVmknpjZbyvKcL5kwlWj9Omvw5Ip3IgWJJk8jSaYtlu3zM63
-Nwf9JtmYhST/WSMDmu2dnajkXjjO11INb9I/bbEFa0nOipFGc/T2L/Coc3cOZayh
-jWZSaX5LaAzHHjcng6WMxwLkFM1JAbBzs/3GkDpv0mztO+7skb6iQ12LAEpmJURw
-3kAP+HwV96LOPNdeE4yBFxgX0b3xdxA61GU5wSesVywlVP+i2k+KYTlerj1KjL0=
------END CERTIFICATE-----
-
-# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
-# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
-# Label: "emSign Root CA - G1"
-# Serial: 235931866688319308814040
-# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
-# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
-# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
------BEGIN CERTIFICATE-----
-MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
-VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
-ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
-MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
-MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
-Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
-BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
-f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
-8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
-d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
-tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
-Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
-o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
-AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
-PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
-wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
-GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
-6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
-RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
-iN66zB+Afko=
------END CERTIFICATE-----
-
-# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
-# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
-# Label: "emSign ECC Root CA - G3"
-# Serial: 287880440101571086945156
-# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
-# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
-# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
------BEGIN CERTIFICATE-----
-MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
-EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
-bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
-RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
-TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
-b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
-djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
-WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
-fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
-zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
-hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
-CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
-+JbNR6iC8hZVdyR+EhCVBCyj
------END CERTIFICATE-----
-
-# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
-# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
-# Label: "emSign Root CA - C1"
-# Serial: 825510296613316004955058
-# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
-# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
-# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
------BEGIN CERTIFICATE-----
-MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
-A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
-SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
-MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
-biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
-dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
-BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
-HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
-3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
-GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
-xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
-aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
-TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
-BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
-/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
-kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
-YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
-+xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
-WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
------END CERTIFICATE-----
-
-# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
-# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
-# Label: "emSign ECC Root CA - C3"
-# Serial: 582948710642506000014504
-# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
-# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
-# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
------BEGIN CERTIFICATE-----
-MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
-EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
-IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
-MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
-biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
-IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
-MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
-sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
-BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
-Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
-3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
-0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
------END CERTIFICATE-----
-
-# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
-# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
-# Label: "Hongkong Post Root CA 3"
-# Serial: 46170865288971385588281144162979347873371282084
-# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
-# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
-# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
------BEGIN CERTIFICATE-----
-MIIFzzCCA7egAwIBAgIUCBZfikyl7ADJk0DfxMauI7gcWqQwDQYJKoZIhvcNAQEL
-BQAwbzELMAkGA1UEBhMCSEsxEjAQBgNVBAgTCUhvbmcgS29uZzESMBAGA1UEBxMJ
-SG9uZyBLb25nMRYwFAYDVQQKEw1Ib25na29uZyBQb3N0MSAwHgYDVQQDExdIb25n
-a29uZyBQb3N0IFJvb3QgQ0EgMzAeFw0xNzA2MDMwMjI5NDZaFw00MjA2MDMwMjI5
-NDZaMG8xCzAJBgNVBAYTAkhLMRIwEAYDVQQIEwlIb25nIEtvbmcxEjAQBgNVBAcT
-CUhvbmcgS29uZzEWMBQGA1UEChMNSG9uZ2tvbmcgUG9zdDEgMB4GA1UEAxMXSG9u
-Z2tvbmcgUG9zdCBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQCziNfqzg8gTr7m1gNt7ln8wlffKWihgw4+aMdoWJwcYEuJQwy51BWy7sFO
-dem1p+/l6TWZ5Mwc50tfjTMwIDNT2aa71T4Tjukfh0mtUC1Qyhi+AViiE3CWu4mI
-VoBc+L0sPOFMV4i707mV78vH9toxdCim5lSJ9UExyuUmGs2C4HDaOym71QP1mbpV
-9WTRYA6ziUm4ii8F0oRFKHyPaFASePwLtVPLwpgchKOesL4jpNrcyCse2m5FHomY
-2vkALgbpDDtw1VAliJnLzXNg99X/NWfFobxeq81KuEXryGgeDQ0URhLj0mRiikKY
-vLTGCAj4/ahMZJx2Ab0vqWwzD9g/KLg8aQFChn5pwckGyuV6RmXpwtZQQS4/t+Tt
-bNe/JgERohYpSms0BpDsE9K2+2p20jzt8NYt3eEV7KObLyzJPivkaTv/ciWxNoZb
-x39ri1UbSsUgYT2uy1DhCDq+sI9jQVMwCFk8mB13umOResoQUGC/8Ne8lYePl8X+
-l2oBlKN8W4UdKjk60FSh0Tlxnf0h+bV78OLgAo9uliQlLKAeLKjEiafv7ZkGL7YK
-TE/bosw3Gq9HhS2KX8Q0NEwA/RiTZxPRN+ZItIsGxVd7GYYKecsAyVKvQv83j+Gj
-Hno9UKtjBucVtT+2RTeUN7F+8kjDf8V1/peNRY8apxpyKBpADwIDAQABo2MwYTAP
-BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBQXnc0e
-i9Y5K3DTXNSguB+wAPzFYTAdBgNVHQ4EFgQUF53NHovWOStw01zUoLgfsAD8xWEw
-DQYJKoZIhvcNAQELBQADggIBAFbVe27mIgHSQpsY1Q7XZiNc4/6gx5LS6ZStS6LG
-7BJ8dNVI0lkUmcDrudHr9EgwW62nV3OZqdPlt9EuWSRY3GguLmLYauRwCy0gUCCk
-MpXRAJi70/33MvJJrsZ64Ee+bs7Lo3I6LWldy8joRTnU+kLBEUx3XZL7av9YROXr
-gZ6voJmtvqkBZss4HTzfQx/0TW60uhdG/H39h4F5ag0zD/ov+BS5gLNdTaqX4fnk
-GMX41TiMJjz98iji7lpJiCzfeT2OnpA8vUFKOt1b9pq0zj8lMH8yfaIDlNDceqFS
-3m6TjRgm/VWsvY+b0s+v54Ysyx8Jb6NvqYTUc79NoXQbTiNg8swOqn+knEwlqLJm
-Ozj/2ZQw9nKEvmhVEA/GcywWaZMH/rFF7buiVWqw2rVKAiUnhde3t4ZEFolsgCs+
-l6mc1X5VTMbeRRAc6uk7nwNT7u56AQIWeNTowr5GdogTPyK7SBIdUgC0An4hGh6c
-JfTzPV4e0hz5sy229zdcxsshTrD3mUcYhcErulWuBurQB7Lcq9CClnXO0lD+mefP
-L5/ndtFhKvshuzHQqp9HpLIiyhY6UFfEW0NnxWViA0kB60PZ2Pierc+xYw5F9KBa
-LJstxabArahH9CdMOA0uG0k7UvToiIMrVCjU8jVStDKDYmlkDJGcn5fqdBb9HxEG
-mpv0
------END CERTIFICATE-----
-
-# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
-# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
-# Label: "Entrust Root Certification Authority - G4"
-# Serial: 289383649854506086828220374796556676440
-# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
-# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
-# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
------BEGIN CERTIFICATE-----
-MIIGSzCCBDOgAwIBAgIRANm1Q3+vqTkPAAAAAFVlrVgwDQYJKoZIhvcNAQELBQAw
-gb4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQL
-Ex9TZWUgd3d3LmVudHJ1c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykg
-MjAxNSBFbnRydXN0LCBJbmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAw
-BgNVBAMTKUVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0
-MB4XDTE1MDUyNzExMTExNloXDTM3MTIyNzExNDExNlowgb4xCzAJBgNVBAYTAlVT
-MRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1
-c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxNSBFbnRydXN0LCBJ
-bmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAwBgNVBAMTKUVudHJ1c3Qg
-Um9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0MIICIjANBgkqhkiG9w0B
-AQEFAAOCAg8AMIICCgKCAgEAsewsQu7i0TD/pZJH4i3DumSXbcr3DbVZwbPLqGgZ
-2K+EbTBwXX7zLtJTmeH+H17ZSK9dE43b/2MzTdMAArzE+NEGCJR5WIoV3imz/f3E
-T+iq4qA7ec2/a0My3dl0ELn39GjUu9CH1apLiipvKgS1sqbHoHrmSKvS0VnM1n4j
-5pds8ELl3FFLFUHtSUrJ3hCX1nbB76W1NhSXNdh4IjVS70O92yfbYVaCNNzLiGAM
-C1rlLAHGVK/XqsEQe9IFWrhAnoanw5CGAlZSCXqc0ieCU0plUmr1POeo8pyvi73T
-DtTUXm6Hnmo9RR3RXRv06QqsYJn7ibT/mCzPfB3pAqoEmh643IhuJbNsZvc8kPNX
-wbMv9W3y+8qh+CmdRouzavbmZwe+LGcKKh9asj5XxNMhIWNlUpEbsZmOeX7m640A
-2Vqq6nPopIICR5b+W45UYaPrL0swsIsjdXJ8ITzI9vF01Bx7owVV7rtNOzK+mndm
-nqxpkCIHH2E6lr7lmk/MBTwoWdPBDFSoWWG9yHJM6Nyfh3+9nEg2XpWjDrk4JFX8
-dWbrAuMINClKxuMrLzOg2qOGpRKX/YAr2hRC45K9PvJdXmd0LhyIRyk0X+IyqJwl
-N4y6mACXi0mWHv0liqzc2thddG5msP9E36EYxr5ILzeUePiVSj9/E15dWf10hkNj
-c0kCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
-VR0OBBYEFJ84xFYjwznooHFs6FRM5Og6sb9nMA0GCSqGSIb3DQEBCwUAA4ICAQAS
-5UKme4sPDORGpbZgQIeMJX6tuGguW8ZAdjwD+MlZ9POrYs4QjbRaZIxowLByQzTS
-Gwv2LFPSypBLhmb8qoMi9IsabyZIrHZ3CL/FmFz0Jomee8O5ZDIBf9PD3Vht7LGr
-hFV0d4QEJ1JrhkzO3bll/9bGXp+aEJlLdWr+aumXIOTkdnrG0CSqkM0gkLpHZPt/
-B7NTeLUKYvJzQ85BK4FqLoUWlFPUa19yIqtRLULVAJyZv967lDtX/Zr1hstWO1uI
-AeV8KEsD+UmDfLJ/fOPtjqF/YFOOVZ1QNBIPt5d7bIdKROf1beyAN/BYGW5KaHbw
-H5Lk6rWS02FREAutp9lfx1/cH6NcjKF+m7ee01ZvZl4HliDtC3T7Zk6LERXpgUl+
-b7DUUH8i119lAg2m9IUe2K4GS0qn0jFmwvjO5QimpAKWRGhXxNUzzxkvFMSUHHuk
-2fCfDrGA4tGeEWSpiBE6doLlYsKA2KSD7ZPvfC+QsDJMlhVoSFLUmQjAJOgc47Ol
-IQ6SwJAfzyBfyjs4x7dtOvPmRLgOMWuIjnDrnBdSqEGULoe256YSxXXfW8AKbnuk
-5F6G+TaU33fD6Q3AOfF5u0aOq0NZJ7cguyPpVkAh7DE9ZapD8j3fcEThuk0mEDuY
-n/PIjhs4ViFqUZPTkcpG2om3PVODLAgfi49T3f+sHw==
------END CERTIFICATE-----
-
-# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
-# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
-# Label: "Microsoft ECC Root Certificate Authority 2017"
-# Serial: 136839042543790627607696632466672567020
-# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
-# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
-# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
------BEGIN CERTIFICATE-----
-MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
-CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
-VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
-MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
-UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
-b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
-hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
-ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
-hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
-BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
-FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
-L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
-iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
------END CERTIFICATE-----
-
-# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
-# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
-# Label: "Microsoft RSA Root Certificate Authority 2017"
-# Serial: 40975477897264996090493496164228220339
-# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
-# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
-# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
------BEGIN CERTIFICATE-----
-MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
-MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
-NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
-IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
-EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
-aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
-MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
-Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
-ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
-HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
-gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
-jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
-aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
-YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
-W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
-UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
-+FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
-W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
-BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
-NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
-LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
-gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
-tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
-SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
-TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
-pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
-xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
-GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
-dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
-AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
-RA+GsCyRxj3qrg+E
------END CERTIFICATE-----
-
-# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
-# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
-# Label: "e-Szigno Root CA 2017"
-# Serial: 411379200276854331539784714
-# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
-# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
-# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
------BEGIN CERTIFICATE-----
-MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
-BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
-LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
-b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
-BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
-THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
-IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
-xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
-Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
-A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
-eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
-jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
-+efcMQ==
------END CERTIFICATE-----
-
-# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
-# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
-# Label: "certSIGN Root CA G2"
-# Serial: 313609486401300475190
-# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
-# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
-# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
------BEGIN CERTIFICATE-----
-MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
-BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
-Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
-BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
-R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
-dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
-vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
-uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
-n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
-cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
-xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
-rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
-DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
-DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
-LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
-eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
-/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
-d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
-kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
-b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
-qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
-OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
-NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
-ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
-pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
-03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
-PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
-1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
-QRBdJ3NghVdJIgc=
------END CERTIFICATE-----
-
-# Issuer: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
-# Subject: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
-# Label: "Trustwave Global Certification Authority"
-# Serial: 1846098327275375458322922162
-# MD5 Fingerprint: f8:1c:18:2d:2f:ba:5f:6d:a1:6c:bc:c7:ab:91:c7:0e
-# SHA1 Fingerprint: 2f:8f:36:4f:e1:58:97:44:21:59:87:a5:2a:9a:d0:69:95:26:7f:b5
-# SHA256 Fingerprint: 97:55:20:15:f5:dd:fc:3c:87:88:c0:06:94:45:55:40:88:94:45:00:84:f1:00:86:70:86:bc:1a:2b:b5:8d:c8
------BEGIN CERTIFICATE-----
-MIIF2jCCA8KgAwIBAgIMBfcOhtpJ80Y1LrqyMA0GCSqGSIb3DQEBCwUAMIGIMQsw
-CQYDVQQGEwJVUzERMA8GA1UECAwISWxsaW5vaXMxEDAOBgNVBAcMB0NoaWNhZ28x
-ITAfBgNVBAoMGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjExMC8GA1UEAwwoVHJ1
-c3R3YXZlIEdsb2JhbCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0xNzA4MjMx
-OTM0MTJaFw00MjA4MjMxOTM0MTJaMIGIMQswCQYDVQQGEwJVUzERMA8GA1UECAwI
-SWxsaW5vaXMxEDAOBgNVBAcMB0NoaWNhZ28xITAfBgNVBAoMGFRydXN0d2F2ZSBI
-b2xkaW5ncywgSW5jLjExMC8GA1UEAwwoVHJ1c3R3YXZlIEdsb2JhbCBDZXJ0aWZp
-Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
-ALldUShLPDeS0YLOvR29zd24q88KPuFd5dyqCblXAj7mY2Hf8g+CY66j96xz0Xzn
-swuvCAAJWX/NKSqIk4cXGIDtiLK0thAfLdZfVaITXdHG6wZWiYj+rDKd/VzDBcdu
-7oaJuogDnXIhhpCujwOl3J+IKMujkkkP7NAP4m1ET4BqstTnoApTAbqOl5F2brz8
-1Ws25kCI1nsvXwXoLG0R8+eyvpJETNKXpP7ScoFDB5zpET71ixpZfR9oWN0EACyW
-80OzfpgZdNmcc9kYvkHHNHnZ9GLCQ7mzJ7Aiy/k9UscwR7PJPrhq4ufogXBeQotP
-JqX+OsIgbrv4Fo7NDKm0G2x2EOFYeUY+VM6AqFcJNykbmROPDMjWLBz7BegIlT1l
-RtzuzWniTY+HKE40Cz7PFNm73bZQmq131BnW2hqIyE4bJ3XYsgjxroMwuREOzYfw
-hI0Vcnyh78zyiGG69Gm7DIwLdVcEuE4qFC49DxweMqZiNu5m4iK4BUBjECLzMx10
-coos9TkpoNPnG4CELcU9402x/RpvumUHO1jsQkUm+9jaJXLE9gCxInm943xZYkqc
-BW89zubWR2OZxiRvchLIrH+QtAuRcOi35hYQcRfO3gZPSEF9NUqjifLJS3tBEW1n
-twiYTOURGa5CgNz7kAXU+FDKvuStx8KU1xad5hePrzb7AgMBAAGjQjBAMA8GA1Ud
-EwEB/wQFMAMBAf8wHQYDVR0OBBYEFJngGWcNYtt2s9o9uFvo/ULSMQ6HMA4GA1Ud
-DwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAmHNw4rDT7TnsTGDZqRKGFx6W
-0OhUKDtkLSGm+J1WE2pIPU/HPinbbViDVD2HfSMF1OQc3Og4ZYbFdada2zUFvXfe
-uyk3QAUHw5RSn8pk3fEbK9xGChACMf1KaA0HZJDmHvUqoai7PF35owgLEQzxPy0Q
-lG/+4jSHg9bP5Rs1bdID4bANqKCqRieCNqcVtgimQlRXtpla4gt5kNdXElE1GYhB
-aCXUNxeEFfsBctyV3lImIJgm4nb1J2/6ADtKYdkNy1GTKv0WBpanI5ojSP5RvbbE
-sLFUzt5sQa0WZ37b/TjNuThOssFgy50X31ieemKyJo90lZvkWx3SD92YHJtZuSPT
-MaCm/zjdzyBP6VhWOmfD0faZmZ26NraAL4hHT4a/RDqA5Dccprrql5gR0IRiR2Qe
-qu5AvzSxnI9O4fKSTx+O856X3vOmeWqJcU9LJxdI/uz0UA9PSX3MReO9ekDFQdxh
-VicGaeVyQYHTtgGJoC86cnn+OjC/QezHYj6RS8fZMXZC+fc8Y+wmjHMMfRod6qh8
-h6jCJ3zhM0EPz8/8AKAigJ5Kp28AsEFFtyLKaEjFQqKu3R3y4G5OBVixwJAWKqQ9
-EEC+j2Jjg6mcgn0tAumDMHzLJ8n9HmYAsC7TIS+OMxZsmO0QqAfWzJPP29FpHOTK
-yeC2nOnOcXHebD8WpHk=
------END CERTIFICATE-----
-
-# Issuer: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
-# Subject: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
-# Label: "Trustwave Global ECC P256 Certification Authority"
-# Serial: 4151900041497450638097112925
-# MD5 Fingerprint: 5b:44:e3:8d:5d:36:86:26:e8:0d:05:d2:59:a7:83:54
-# SHA1 Fingerprint: b4:90:82:dd:45:0c:be:8b:5b:b1:66:d3:e2:a4:08:26:cd:ed:42:cf
-# SHA256 Fingerprint: 94:5b:bc:82:5e:a5:54:f4:89:d1:fd:51:a7:3d:df:2e:a6:24:ac:70:19:a0:52:05:22:5c:22:a7:8c:cf:a8:b4
------BEGIN CERTIFICATE-----
-MIICYDCCAgegAwIBAgIMDWpfCD8oXD5Rld9dMAoGCCqGSM49BAMCMIGRMQswCQYD
-VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
-BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
-YXZlIEdsb2JhbCBFQ0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
-NzA4MjMxOTM1MTBaFw00MjA4MjMxOTM1MTBaMIGRMQswCQYDVQQGEwJVUzERMA8G
-A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
-d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
-Q0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTBZMBMGByqGSM49AgEGCCqG
-SM49AwEHA0IABH77bOYj43MyCMpg5lOcunSNGLB4kFKA3TjASh3RqMyTpJcGOMoN
-FWLGjgEqZZ2q3zSRLoHB5DOSMcT9CTqmP62jQzBBMA8GA1UdEwEB/wQFMAMBAf8w
-DwYDVR0PAQH/BAUDAwcGADAdBgNVHQ4EFgQUo0EGrJBt0UrrdaVKEJmzsaGLSvcw
-CgYIKoZIzj0EAwIDRwAwRAIgB+ZU2g6gWrKuEZ+Hxbb/ad4lvvigtwjzRM4q3wgh
-DDcCIC0mA6AFvWvR9lz4ZcyGbbOcNEhjhAnFjXca4syc4XR7
------END CERTIFICATE-----
-
-# Issuer: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
-# Subject: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
-# Label: "Trustwave Global ECC P384 Certification Authority"
-# Serial: 2704997926503831671788816187
-# MD5 Fingerprint: ea:cf:60:c4:3b:b9:15:29:40:a1:97:ed:78:27:93:d6
-# SHA1 Fingerprint: e7:f3:a3:c8:cf:6f:c3:04:2e:6d:0e:67:32:c5:9e:68:95:0d:5e:d2
-# SHA256 Fingerprint: 55:90:38:59:c8:c0:c3:eb:b8:75:9e:ce:4e:25:57:22:5f:f5:75:8b:bd:38:eb:d4:82:76:60:1e:1b:d5:80:97
------BEGIN CERTIFICATE-----
-MIICnTCCAiSgAwIBAgIMCL2Fl2yZJ6SAaEc7MAoGCCqGSM49BAMDMIGRMQswCQYD
-VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
-BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
-YXZlIEdsb2JhbCBFQ0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
-NzA4MjMxOTM2NDNaFw00MjA4MjMxOTM2NDNaMIGRMQswCQYDVQQGEwJVUzERMA8G
-A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
-d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
-Q0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTB2MBAGByqGSM49AgEGBSuB
-BAAiA2IABGvaDXU1CDFHBa5FmVXxERMuSvgQMSOjfoPTfygIOiYaOs+Xgh+AtycJ
-j9GOMMQKmw6sWASr9zZ9lCOkmwqKi6vr/TklZvFe/oyujUF5nQlgziip04pt89ZF
-1PKYhDhloKNDMEEwDwYDVR0TAQH/BAUwAwEB/zAPBgNVHQ8BAf8EBQMDBwYAMB0G
-A1UdDgQWBBRVqYSJ0sEyvRjLbKYHTsjnnb6CkDAKBggqhkjOPQQDAwNnADBkAjA3
-AZKXRRJ+oPM+rRk6ct30UJMDEr5E0k9BpIycnR+j9sKS50gU/k6bpZFXrsY3crsC
-MGclCrEMXu6pY5Jv5ZAL/mYiykf9ijH3g/56vxC+GCsej/YpHpRZ744hN8tRmKVu
-Sw==
------END CERTIFICATE-----
-
-# Issuer: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
-# Subject: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
-# Label: "NAVER Global Root Certification Authority"
-# Serial: 9013692873798656336226253319739695165984492813
-# MD5 Fingerprint: c8:7e:41:f6:25:3b:f5:09:b3:17:e8:46:3d:bf:d0:9b
-# SHA1 Fingerprint: 8f:6b:f2:a9:27:4a:da:14:a0:c4:f4:8e:61:27:f9:c0:1e:78:5d:d1
-# SHA256 Fingerprint: 88:f4:38:dc:f8:ff:d1:fa:8f:42:91:15:ff:e5:f8:2a:e1:e0:6e:0c:70:c3:75:fa:ad:71:7b:34:a4:9e:72:65
------BEGIN CERTIFICATE-----
-MIIFojCCA4qgAwIBAgIUAZQwHqIL3fXFMyqxQ0Rx+NZQTQ0wDQYJKoZIhvcNAQEM
-BQAwaTELMAkGA1UEBhMCS1IxJjAkBgNVBAoMHU5BVkVSIEJVU0lORVNTIFBMQVRG
-T1JNIENvcnAuMTIwMAYDVQQDDClOQVZFUiBHbG9iYWwgUm9vdCBDZXJ0aWZpY2F0
-aW9uIEF1dGhvcml0eTAeFw0xNzA4MTgwODU4NDJaFw0zNzA4MTgyMzU5NTlaMGkx
-CzAJBgNVBAYTAktSMSYwJAYDVQQKDB1OQVZFUiBCVVNJTkVTUyBQTEFURk9STSBD
-b3JwLjEyMDAGA1UEAwwpTkFWRVIgR2xvYmFsIFJvb3QgQ2VydGlmaWNhdGlvbiBB
-dXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC21PGTXLVA
-iQqrDZBbUGOukJR0F0Vy1ntlWilLp1agS7gvQnXp2XskWjFlqxcX0TM62RHcQDaH
-38dq6SZeWYp34+hInDEW+j6RscrJo+KfziFTowI2MMtSAuXaMl3Dxeb57hHHi8lE
-HoSTGEq0n+USZGnQJoViAbbJAh2+g1G7XNr4rRVqmfeSVPc0W+m/6imBEtRTkZaz
-kVrd/pBzKPswRrXKCAfHcXLJZtM0l/aM9BhK4dA9WkW2aacp+yPOiNgSnABIqKYP
-szuSjXEOdMWLyEz59JuOuDxp7W87UC9Y7cSw0BwbagzivESq2M0UXZR4Yb8Obtoq
-vC8MC3GmsxY/nOb5zJ9TNeIDoKAYv7vxvvTWjIcNQvcGufFt7QSUqP620wbGQGHf
-nZ3zVHbOUzoBppJB7ASjjw2i1QnK1sua8e9DXcCrpUHPXFNwcMmIpi3Ua2FzUCaG
-YQ5fG8Ir4ozVu53BA0K6lNpfqbDKzE0K70dpAy8i+/Eozr9dUGWokG2zdLAIx6yo
-0es+nPxdGoMuK8u180SdOqcXYZaicdNwlhVNt0xz7hlcxVs+Qf6sdWA7G2POAN3a
-CJBitOUt7kinaxeZVL6HSuOpXgRM6xBtVNbv8ejyYhbLgGvtPe31HzClrkvJE+2K
-AQHJuFFYwGY6sWZLxNUxAmLpdIQM201GLQIDAQABo0IwQDAdBgNVHQ4EFgQU0p+I
-36HNLL3s9TsBAZMzJ7LrYEswDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMB
-Af8wDQYJKoZIhvcNAQEMBQADggIBADLKgLOdPVQG3dLSLvCkASELZ0jKbY7gyKoN
-qo0hV4/GPnrK21HUUrPUloSlWGB/5QuOH/XcChWB5Tu2tyIvCZwTFrFsDDUIbatj
-cu3cvuzHV+YwIHHW1xDBE1UBjCpD5EHxzzp6U5LOogMFDTjfArsQLtk70pt6wKGm
-+LUx5vR1yblTmXVHIloUFcd4G7ad6Qz4G3bxhYTeodoS76TiEJd6eN4MUZeoIUCL
-hr0N8F5OSza7OyAfikJW4Qsav3vQIkMsRIz75Sq0bBwcupTgE34h5prCy8VCZLQe
-lHsIJchxzIdFV4XTnyliIoNRlwAYl3dqmJLJfGBs32x9SuRwTMKeuB330DTHD8z7
-p/8Dvq1wkNoL3chtl1+afwkyQf3NosxabUzyqkn+Zvjp2DXrDige7kgvOtB5CTh8
-piKCk5XQA76+AqAF3SAi428diDRgxuYKuQl1C/AH6GmWNcf7I4GOODm4RStDeKLR
-LBT/DShycpWbXgnbiUSYqqFJu3FS8r/2/yehNq+4tneI3TqkbZs0kNwUXTC/t+sX
-5Ie3cdCh13cV1ELX8vMxmV2b3RZtP+oGI/hGoiLtk/bdmuYqh7GYVPEi92tF4+KO
-dh2ajcQGjTa3FPOdVGm3jjzVpG2Tgbet9r1ke8LJaDmgkpzNNIaRkPpkUZ3+/uul
-9XXeifdy
------END CERTIFICATE-----
-
-# Issuer: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
-# Subject: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
-# Label: "AC RAIZ FNMT-RCM SERVIDORES SEGUROS"
-# Serial: 131542671362353147877283741781055151509
-# MD5 Fingerprint: 19:36:9c:52:03:2f:d2:d1:bb:23:cc:dd:1e:12:55:bb
-# SHA1 Fingerprint: 62:ff:d9:9e:c0:65:0d:03:ce:75:93:d2:ed:3f:2d:32:c9:e3:e5:4a
-# SHA256 Fingerprint: 55:41:53:b1:3d:2c:f9:dd:b7:53:bf:be:1a:4e:0a:e0:8d:0a:a4:18:70:58:fe:60:a2:b8:62:b2:e4:b8:7b:cb
------BEGIN CERTIFICATE-----
-MIICbjCCAfOgAwIBAgIQYvYybOXE42hcG2LdnC6dlTAKBggqhkjOPQQDAzB4MQsw
-CQYDVQQGEwJFUzERMA8GA1UECgwIRk5NVC1SQ00xDjAMBgNVBAsMBUNlcmVzMRgw
-FgYDVQRhDA9WQVRFUy1RMjgyNjAwNEoxLDAqBgNVBAMMI0FDIFJBSVogRk5NVC1S
-Q00gU0VSVklET1JFUyBTRUdVUk9TMB4XDTE4MTIyMDA5MzczM1oXDTQzMTIyMDA5
-MzczM1oweDELMAkGA1UEBhMCRVMxETAPBgNVBAoMCEZOTVQtUkNNMQ4wDAYDVQQL
-DAVDZXJlczEYMBYGA1UEYQwPVkFURVMtUTI4MjYwMDRKMSwwKgYDVQQDDCNBQyBS
-QUlaIEZOTVQtUkNNIFNFUlZJRE9SRVMgU0VHVVJPUzB2MBAGByqGSM49AgEGBSuB
-BAAiA2IABPa6V1PIyqvfNkpSIeSX0oNnnvBlUdBeh8dHsVnyV0ebAAKTRBdp20LH
-sbI6GA60XYyzZl2hNPk2LEnb80b8s0RpRBNm/dfF/a82Tc4DTQdxz69qBdKiQ1oK
-Um8BA06Oi6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
-VR0OBBYEFAG5L++/EYZg8k/QQW6rcx/n0m5JMAoGCCqGSM49BAMDA2kAMGYCMQCu
-SuMrQMN0EfKVrRYj3k4MGuZdpSRea0R7/DjiT8ucRRcRTBQnJlU5dUoDzBOQn5IC
-MQD6SmxgiHPz7riYYqnOK8LZiqZwMR2vsJRM60/G49HzYqc8/5MuB1xJAWdpEgJy
-v+c=
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign Root R46 O=GlobalSign nv-sa
-# Subject: CN=GlobalSign Root R46 O=GlobalSign nv-sa
-# Label: "GlobalSign Root R46"
-# Serial: 1552617688466950547958867513931858518042577
-# MD5 Fingerprint: c4:14:30:e4:fa:66:43:94:2a:6a:1b:24:5f:19:d0:ef
-# SHA1 Fingerprint: 53:a2:b0:4b:ca:6b:d6:45:e6:39:8a:8e:c4:0d:d2:bf:77:c3:a2:90
-# SHA256 Fingerprint: 4f:a3:12:6d:8d:3a:11:d1:c4:85:5a:4f:80:7c:ba:d6:cf:91:9d:3a:5a:88:b0:3b:ea:2c:63:72:d9:3c:40:c9
------BEGIN CERTIFICATE-----
-MIIFWjCCA0KgAwIBAgISEdK7udcjGJ5AXwqdLdDfJWfRMA0GCSqGSIb3DQEBDAUA
-MEYxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYD
-VQQDExNHbG9iYWxTaWduIFJvb3QgUjQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMy
-MDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYt
-c2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
-AQUAA4ICDwAwggIKAoICAQCsrHQy6LNl5brtQyYdpokNRbopiLKkHWPd08EsCVeJ
-OaFV6Wc0dwxu5FUdUiXSE2te4R2pt32JMl8Nnp8semNgQB+msLZ4j5lUlghYruQG
-vGIFAha/r6gjA7aUD7xubMLL1aa7DOn2wQL7Id5m3RerdELv8HQvJfTqa1VbkNud
-316HCkD7rRlr+/fKYIje2sGP1q7Vf9Q8g+7XFkyDRTNrJ9CG0Bwta/OrffGFqfUo
-0q3v84RLHIf8E6M6cqJaESvWJ3En7YEtbWaBkoe0G1h6zD8K+kZPTXhc+CtI4wSE
-y132tGqzZfxCnlEmIyDLPRT5ge1lFgBPGmSXZgjPjHvjK8Cd+RTyG/FWaha/LIWF
-zXg4mutCagI0GIMXTpRW+LaCtfOW3T3zvn8gdz57GSNrLNRyc0NXfeD412lPFzYE
-+cCQYDdF3uYM2HSNrpyibXRdQr4G9dlkbgIQrImwTDsHTUB+JMWKmIJ5jqSngiCN
-I/onccnfxkF0oE32kRbcRoxfKWMxWXEM2G/CtjJ9++ZdU6Z+Ffy7dXxd7Pj2Fxzs
-x2sZy/N78CsHpdlseVR2bJ0cpm4O6XkMqCNqo98bMDGfsVR7/mrLZqrcZdCinkqa
-ByFrgY/bxFn63iLABJzjqls2k+g9vXqhnQt2sQvHnf3PmKgGwvgqo6GDoLclcqUC
-4wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
-HQ4EFgQUA1yrc4GHqMywptWU4jaWSf8FmSwwDQYJKoZIhvcNAQEMBQADggIBAHx4
-7PYCLLtbfpIrXTncvtgdokIzTfnvpCo7RGkerNlFo048p9gkUbJUHJNOxO97k4Vg
-JuoJSOD1u8fpaNK7ajFxzHmuEajwmf3lH7wvqMxX63bEIaZHU1VNaL8FpO7XJqti
-2kM3S+LGteWygxk6x9PbTZ4IevPuzz5i+6zoYMzRx6Fcg0XERczzF2sUyQQCPtIk
-pnnpHs6i58FZFZ8d4kuaPp92CC1r2LpXFNqD6v6MVenQTqnMdzGxRBF6XLE+0xRF
-FRhiJBPSy03OXIPBNvIQtQ6IbbjhVp+J3pZmOUdkLG5NrmJ7v2B0GbhWrJKsFjLt
-rWhV/pi60zTe9Mlhww6G9kuEYO4Ne7UyWHmRVSyBQ7N0H3qqJZ4d16GLuc1CLgSk
-ZoNNiTW2bKg2SnkheCLQQrzRQDGQob4Ez8pn7fXwgNNgyYMqIgXQBztSvwyeqiv5
-u+YfjyW6hY0XHgL+XVAEV8/+LbzvXMAaq7afJMbfc2hIkCwU9D9SGuTSyxTDYWnP
-4vkYxboznxSjBF25cfe1lNj2M8FawTSLfJvdkzrnE6JwYZ+vj+vYxXX4M2bUdGc6
-N3ec592kD3ZDZopD8p/7DEJ4Y9HiD2971KE9dJeFt0g5QdYg/NA6s/rob8SKunE3
-vouXsXgxT7PntgMTzlSdriVZzH81Xwj3QEUxeCp6
------END CERTIFICATE-----
-
-# Issuer: CN=GlobalSign Root E46 O=GlobalSign nv-sa
-# Subject: CN=GlobalSign Root E46 O=GlobalSign nv-sa
-# Label: "GlobalSign Root E46"
-# Serial: 1552617690338932563915843282459653771421763
-# MD5 Fingerprint: b5:b8:66:ed:de:08:83:e3:c9:e2:01:34:06:ac:51:6f
-# SHA1 Fingerprint: 39:b4:6c:d5:fe:80:06:eb:e2:2f:4a:bb:08:33:a0:af:db:b9:dd:84
-# SHA256 Fingerprint: cb:b9:c4:4d:84:b8:04:3e:10:50:ea:31:a6:9f:51:49:55:d7:bf:d2:e2:c6:b4:93:01:01:9a:d6:1d:9f:50:58
------BEGIN CERTIFICATE-----
-MIICCzCCAZGgAwIBAgISEdK7ujNu1LzmJGjFDYQdmOhDMAoGCCqGSM49BAMDMEYx
-CzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYDVQQD
-ExNHbG9iYWxTaWduIFJvb3QgRTQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMyMDAw
-MDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2Ex
-HDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
-IgNiAAScDrHPt+ieUnd1NPqlRqetMhkytAepJ8qUuwzSChDH2omwlwxwEwkBjtjq
-R+q+soArzfwoDdusvKSGN+1wCAB16pMLey5SnCNoIwZD7JIvU4Tb+0cUB+hflGdd
-yXqBPCCjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
-DgQWBBQxCpCPtsad0kRLgLWi5h+xEk8blTAKBggqhkjOPQQDAwNoADBlAjEA31SQ
-7Zvvi5QCkxeCmb6zniz2C5GMn0oUsfZkvLtoURMMA/cVi4RguYv/Uo7njLwcAjA8
-+RHUjE7AwWHCFUyqqx0LMV87HOIAl0Qx5v5zli/altP+CAezNIm8BZ/3Hobui3A=
------END CERTIFICATE-----
-
-# Issuer: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
-# Subject: CN=GLOBALTRUST 2020 O=e-commerce monitoring GmbH
-# Label: "GLOBALTRUST 2020"
-# Serial: 109160994242082918454945253
-# MD5 Fingerprint: 8a:c7:6f:cb:6d:e3:cc:a2:f1:7c:83:fa:0e:78:d7:e8
-# SHA1 Fingerprint: d0:67:c1:13:51:01:0c:aa:d0:c7:6a:65:37:31:16:26:4f:53:71:a2
-# SHA256 Fingerprint: 9a:29:6a:51:82:d1:d4:51:a2:e3:7f:43:9b:74:da:af:a2:67:52:33:29:f9:0f:9a:0d:20:07:c3:34:e2:3c:9a
------BEGIN CERTIFICATE-----
-MIIFgjCCA2qgAwIBAgILWku9WvtPilv6ZeUwDQYJKoZIhvcNAQELBQAwTTELMAkG
-A1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9uaXRvcmluZyBHbWJIMRkw
-FwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMB4XDTIwMDIxMDAwMDAwMFoXDTQwMDYx
-MDAwMDAwMFowTTELMAkGA1UEBhMCQVQxIzAhBgNVBAoTGmUtY29tbWVyY2UgbW9u
-aXRvcmluZyBHbWJIMRkwFwYDVQQDExBHTE9CQUxUUlVTVCAyMDIwMIICIjANBgkq
-hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAri5WrRsc7/aVj6B3GyvTY4+ETUWiD59b
-RatZe1E0+eyLinjF3WuvvcTfk0Uev5E4C64OFudBc/jbu9G4UeDLgztzOG53ig9Z
-YybNpyrOVPu44sB8R85gfD+yc/LAGbaKkoc1DZAoouQVBGM+uq/ufF7MpotQsjj3
-QWPKzv9pj2gOlTblzLmMCcpL3TGQlsjMH/1WljTbjhzqLL6FLmPdqqmV0/0plRPw
-yJiT2S0WR5ARg6I6IqIoV6Lr/sCMKKCmfecqQjuCgGOlYx8ZzHyyZqjC0203b+J+
-BlHZRYQfEs4kUmSFC0iAToexIiIwquuuvuAC4EDosEKAA1GqtH6qRNdDYfOiaxaJ
-SaSjpCuKAsR49GiKweR6NrFvG5Ybd0mN1MkGco/PU+PcF4UgStyYJ9ORJitHHmkH
-r96i5OTUawuzXnzUJIBHKWk7buis/UDr2O1xcSvy6Fgd60GXIsUf1DnQJ4+H4xj0
-4KlGDfV0OoIu0G4skaMxXDtG6nsEEFZegB31pWXogvziB4xiRfUg3kZwhqG8k9Me
-dKZssCz3AwyIDMvUclOGvGBG85hqwvG/Q/lwIHfKN0F5VVJjjVsSn8VoxIidrPIw
-q7ejMZdnrY8XD2zHc+0klGvIg5rQmjdJBKuxFshsSUktq6HQjJLyQUp5ISXbY9e2
-nKd+Qmn7OmMCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
-AQYwHQYDVR0OBBYEFNwuH9FhN3nkq9XVsxJxaD1qaJwiMB8GA1UdIwQYMBaAFNwu
-H9FhN3nkq9XVsxJxaD1qaJwiMA0GCSqGSIb3DQEBCwUAA4ICAQCR8EICaEDuw2jA
-VC/f7GLDw56KoDEoqoOOpFaWEhCGVrqXctJUMHytGdUdaG/7FELYjQ7ztdGl4wJC
-XtzoRlgHNQIw4Lx0SsFDKv/bGtCwr2zD/cuz9X9tAy5ZVp0tLTWMstZDFyySCstd
-6IwPS3BD0IL/qMy/pJTAvoe9iuOTe8aPmxadJ2W8esVCgmxcB9CpwYhgROmYhRZf
-+I/KARDOJcP5YBugxZfD0yyIMaK9MOzQ0MAS8cE54+X1+NZK3TTN+2/BT+MAi1bi
-kvcoskJ3ciNnxz8RFbLEAwW+uxF7Cr+obuf/WEPPm2eggAe2HcqtbepBEX4tdJP7
-wry+UUTF72glJ4DjyKDUEuzZpTcdN3y0kcra1LGWge9oXHYQSa9+pTeAsRxSvTOB
-TI/53WXZFM2KJVj04sWDpQmQ1GwUY7VA3+vA/MRYfg0UFodUJ25W5HCEuGwyEn6C
-MUO+1918oa2u1qsgEu8KwxCMSZY13At1XrFP1U80DhEgB3VDRemjEdqso5nCtnkn
-4rnvyOL2NSl6dPrFf4IFYqYK6miyeUcGbvJXqBUzxvd4Sj1Ce2t+/vdG6tHrju+I
-aFvowdlxfv1k7/9nR4hYJS8+hge9+6jlgqispdNpQ80xiEmEU5LAsTkbOYMBMMTy
-qfrQA71yN2BWHzZ8vTmR9W0Nv3vXkg==
------END CERTIFICATE-----
-
-# Issuer: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
-# Subject: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
-# Label: "ANF Secure Server Root CA"
-# Serial: 996390341000653745
-# MD5 Fingerprint: 26:a6:44:5a:d9:af:4e:2f:b2:1d:b6:65:b0:4e:e8:96
-# SHA1 Fingerprint: 5b:6e:68:d0:cc:15:b6:a0:5f:1e:c1:5f:ae:02:fc:6b:2f:5d:6f:74
-# SHA256 Fingerprint: fb:8f:ec:75:91:69:b9:10:6b:1e:51:16:44:c6:18:c5:13:04:37:3f:6c:06:43:08:8d:8b:ef:fd:1b:99:75:99
------BEGIN CERTIFICATE-----
-MIIF7zCCA9egAwIBAgIIDdPjvGz5a7EwDQYJKoZIhvcNAQELBQAwgYQxEjAQBgNV
-BAUTCUc2MzI4NzUxMDELMAkGA1UEBhMCRVMxJzAlBgNVBAoTHkFORiBBdXRvcmlk
-YWQgZGUgQ2VydGlmaWNhY2lvbjEUMBIGA1UECxMLQU5GIENBIFJhaXoxIjAgBgNV
-BAMTGUFORiBTZWN1cmUgU2VydmVyIFJvb3QgQ0EwHhcNMTkwOTA0MTAwMDM4WhcN
-MzkwODMwMTAwMDM4WjCBhDESMBAGA1UEBRMJRzYzMjg3NTEwMQswCQYDVQQGEwJF
-UzEnMCUGA1UEChMeQU5GIEF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uMRQwEgYD
-VQQLEwtBTkYgQ0EgUmFpejEiMCAGA1UEAxMZQU5GIFNlY3VyZSBTZXJ2ZXIgUm9v
-dCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANvrayvmZFSVgpCj
-cqQZAZ2cC4Ffc0m6p6zzBE57lgvsEeBbphzOG9INgxwruJ4dfkUyYA8H6XdYfp9q
-yGFOtibBTI3/TO80sh9l2Ll49a2pcbnvT1gdpd50IJeh7WhM3pIXS7yr/2WanvtH
-2Vdy8wmhrnZEE26cLUQ5vPnHO6RYPUG9tMJJo8gN0pcvB2VSAKduyK9o7PQUlrZX
-H1bDOZ8rbeTzPvY1ZNoMHKGESy9LS+IsJJ1tk0DrtSOOMspvRdOoiXsezx76W0OL
-zc2oD2rKDF65nkeP8Nm2CgtYZRczuSPkdxl9y0oukntPLxB3sY0vaJxizOBQ+OyR
-p1RMVwnVdmPF6GUe7m1qzwmd+nxPrWAI/VaZDxUse6mAq4xhj0oHdkLePfTdsiQz
-W7i1o0TJrH93PB0j7IKppuLIBkwC/qxcmZkLLxCKpvR/1Yd0DVlJRfbwcVw5Kda/
-SiOL9V8BY9KHcyi1Swr1+KuCLH5zJTIdC2MKF4EA/7Z2Xue0sUDKIbvVgFHlSFJn
-LNJhiQcND85Cd8BEc5xEUKDbEAotlRyBr+Qc5RQe8TZBAQIvfXOn3kLMTOmJDVb3
-n5HUA8ZsyY/b2BzgQJhdZpmYgG4t/wHFzstGH6wCxkPmrqKEPMVOHj1tyRRM4y5B
-u8o5vzY8KhmqQYdOpc5LMnndkEl/AgMBAAGjYzBhMB8GA1UdIwQYMBaAFJxf0Gxj
-o1+TypOYCK2Mh6UsXME3MB0GA1UdDgQWBBScX9BsY6Nfk8qTmAitjIelLFzBNzAO
-BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC
-AgEATh65isagmD9uw2nAalxJUqzLK114OMHVVISfk/CHGT0sZonrDUL8zPB1hT+L
-9IBdeeUXZ701guLyPI59WzbLWoAAKfLOKyzxj6ptBZNscsdW699QIyjlRRA96Gej
-rw5VD5AJYu9LWaL2U/HANeQvwSS9eS9OICI7/RogsKQOLHDtdD+4E5UGUcjohybK
-pFtqFiGS3XNgnhAY3jyB6ugYw3yJ8otQPr0R4hUDqDZ9MwFsSBXXiJCZBMXM5gf0
-vPSQ7RPi6ovDj6MzD8EpTBNO2hVWcXNyglD2mjN8orGoGjR0ZVzO0eurU+AagNjq
-OknkJjCb5RyKqKkVMoaZkgoQI1YS4PbOTOK7vtuNknMBZi9iPrJyJ0U27U1W45eZ
-/zo1PqVUSlJZS2Db7v54EX9K3BR5YLZrZAPbFYPhor72I5dQ8AkzNqdxliXzuUJ9
-2zg/LFis6ELhDtjTO0wugumDLmsx2d1Hhk9tl5EuT+IocTUW0fJz/iUrB0ckYyfI
-+PbZa/wSMVYIwFNCr5zQM378BvAxRAMU8Vjq8moNqRGyg77FGr8H6lnco4g175x2
-MjxNBiLOFeXdntiP2t7SxDnlF4HPOEfrf4htWRvfn0IUrn7PqLBmZdo3r5+qPeoo
-tt7VMVgWglvquxl1AnMaykgaIZOQCo6ThKd9OyMYkomgjaw=
------END CERTIFICATE-----
-
-# Issuer: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
-# Subject: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
-# Label: "Certum EC-384 CA"
-# Serial: 160250656287871593594747141429395092468
-# MD5 Fingerprint: b6:65:b3:96:60:97:12:a1:ec:4e:e1:3d:a3:c6:c9:f1
-# SHA1 Fingerprint: f3:3e:78:3c:ac:df:f4:a2:cc:ac:67:55:69:56:d7:e5:16:3c:e1:ed
-# SHA256 Fingerprint: 6b:32:80:85:62:53:18:aa:50:d1:73:c9:8d:8b:da:09:d5:7e:27:41:3d:11:4c:f7:87:a0:f5:d0:6c:03:0c:f6
------BEGIN CERTIFICATE-----
-MIICZTCCAeugAwIBAgIQeI8nXIESUiClBNAt3bpz9DAKBggqhkjOPQQDAzB0MQsw
-CQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEuMScw
-JQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAXBgNVBAMT
-EENlcnR1bSBFQy0zODQgQ0EwHhcNMTgwMzI2MDcyNDU0WhcNNDMwMzI2MDcyNDU0
-WjB0MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBT
-LkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAX
-BgNVBAMTEENlcnR1bSBFQy0zODQgQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATE
-KI6rGFtqvm5kN2PkzeyrOvfMobgOgknXhimfoZTy42B4mIF4Bk3y7JoOV2CDn7Tm
-Fy8as10CW4kjPMIRBSqniBMY81CE1700LCeJVf/OTOffph8oxPBUw7l8t1Ot68Kj
-QjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI0GZnQkdjrzife81r1HfS+8
-EF9LMA4GA1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNoADBlAjADVS2m5hjEfO/J
-UG7BJw+ch69u1RsIGL2SKcHvlJF40jocVYli5RsJHrpka/F2tNQCMQC0QoSZ/6vn
-nvuRlydd3LBbMHHOXjgaatkl5+r3YZJW+OraNsKHZZYuciUvf9/DE8k=
------END CERTIFICATE-----
-
-# Issuer: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
-# Subject: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
-# Label: "Certum Trusted Root CA"
-# Serial: 40870380103424195783807378461123655149
-# MD5 Fingerprint: 51:e1:c2:e7:fe:4c:84:af:59:0e:2f:f4:54:6f:ea:29
-# SHA1 Fingerprint: c8:83:44:c0:18:ae:9f:cc:f1:87:b7:8f:22:d1:c5:d7:45:84:ba:e5
-# SHA256 Fingerprint: fe:76:96:57:38:55:77:3e:37:a9:5e:7a:d4:d9:cc:96:c3:01:57:c1:5d:31:76:5b:a9:b1:57:04:e1:ae:78:fd
------BEGIN CERTIFICATE-----
-MIIFwDCCA6igAwIBAgIQHr9ZULjJgDdMBvfrVU+17TANBgkqhkiG9w0BAQ0FADB6
-MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEu
-MScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxHzAdBgNV
-BAMTFkNlcnR1bSBUcnVzdGVkIFJvb3QgQ0EwHhcNMTgwMzE2MTIxMDEzWhcNNDMw
-MzE2MTIxMDEzWjB6MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEg
-U3lzdGVtcyBTLkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRo
-b3JpdHkxHzAdBgNVBAMTFkNlcnR1bSBUcnVzdGVkIFJvb3QgQ0EwggIiMA0GCSqG
-SIb3DQEBAQUAA4ICDwAwggIKAoICAQDRLY67tzbqbTeRn06TpwXkKQMlzhyC93yZ
-n0EGze2jusDbCSzBfN8pfktlL5On1AFrAygYo9idBcEq2EXxkd7fO9CAAozPOA/q
-p1x4EaTByIVcJdPTsuclzxFUl6s1wB52HO8AU5853BSlLCIls3Jy/I2z5T4IHhQq
-NwuIPMqw9MjCoa68wb4pZ1Xi/K1ZXP69VyywkI3C7Te2fJmItdUDmj0VDT06qKhF
-8JVOJVkdzZhpu9PMMsmN74H+rX2Ju7pgE8pllWeg8xn2A1bUatMn4qGtg/BKEiJ3
-HAVz4hlxQsDsdUaakFjgao4rpUYwBI4Zshfjvqm6f1bxJAPXsiEodg42MEx51UGa
-mqi4NboMOvJEGyCI98Ul1z3G4z5D3Yf+xOr1Uz5MZf87Sst4WmsXXw3Hw09Omiqi
-7VdNIuJGmj8PkTQkfVXjjJU30xrwCSss0smNtA0Aq2cpKNgB9RkEth2+dv5yXMSF
-ytKAQd8FqKPVhJBPC/PgP5sZ0jeJP/J7UhyM9uH3PAeXjA6iWYEMspA90+NZRu0P
-qafegGtaqge2Gcu8V/OXIXoMsSt0Puvap2ctTMSYnjYJdmZm/Bo/6khUHL4wvYBQ
-v3y1zgD2DGHZ5yQD4OMBgQ692IU0iL2yNqh7XAjlRICMb/gv1SHKHRzQ+8S1h9E6
-Tsd2tTVItQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSM+xx1
-vALTn04uSNn5YFSqxLNP+jAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQENBQAD
-ggIBAEii1QALLtA/vBzVtVRJHlpr9OTy4EA34MwUe7nJ+jW1dReTagVphZzNTxl4
-WxmB82M+w85bj/UvXgF2Ez8sALnNllI5SW0ETsXpD4YN4fqzX4IS8TrOZgYkNCvo
-zMrnadyHncI013nR03e4qllY/p0m+jiGPp2Kh2RX5Rc64vmNueMzeMGQ2Ljdt4NR
-5MTMI9UGfOZR0800McD2RrsLrfw9EAUqO0qRJe6M1ISHgCq8CYyqOhNf6DR5UMEQ
-GfnTKB7U0VEwKbOukGfWHwpjscWpxkIxYxeU72nLL/qMFH3EQxiJ2fAyQOaA4kZf
-5ePBAFmo+eggvIksDkc0C+pXwlM2/KfUrzHN/gLldfq5Jwn58/U7yn2fqSLLiMmq
-0Uc9NneoWWRrJ8/vJ8HjJLWG965+Mk2weWjROeiQWMODvA8s1pfrzgzhIMfatz7D
-P78v3DSk+yshzWePS/Tj6tQ/50+6uaWTRRxmHyH6ZF5v4HaUMst19W7l9o/HuKTM
-qJZ9ZPskWkoDbGs4xugDQ5r3V7mzKWmTOPQD8rv7gmsHINFSH5pkAnuYZttcTVoP
-0ISVoDwUQwbKytu4QTbaakRnh6+v40URFWkIsr4WOZckbxJF0WddCajJFdr60qZf
-E2Efv4WstK2tBZQIgx51F9NxO5NQI1mg7TyRVJ12AMXDuDjb
------END CERTIFICATE-----
diff --git a/addon/globalPlugins/spellcheck/libs/certifi/core.py b/addon/globalPlugins/spellcheck/libs/certifi/core.py
deleted file mode 100644
index 5d2b8cd..0000000
--- a/addon/globalPlugins/spellcheck/libs/certifi/core.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-certifi.py
-~~~~~~~~~~
-
-This module returns the installation location of cacert.pem or its contents.
-"""
-import os
-
-try:
-    from importlib.resources import path as get_path, read_text
-
-    _CACERT_CTX = None
-    _CACERT_PATH = None
-
-    def where():
-        # This is slightly terrible, but we want to delay extracting the file
-        # in cases where we're inside of a zipimport situation until someone
-        # actually calls where(), but we don't want to re-extract the file
-        # on every call of where(), so we'll do it once then store it in a
-        # global variable.
-        global _CACERT_CTX
-        global _CACERT_PATH
-        if _CACERT_PATH is None:
-            # This is slightly janky, the importlib.resources API wants you to
-            # manage the cleanup of this file, so it doesn't actually return a
-            # path, it returns a context manager that will give you the path
-            # when you enter it and will do any cleanup when you leave it. In
-            # the common case of not needing a temporary file, it will just
-            # return the file system location and the __exit__() is a no-op.
-            #
-            # We also have to hold onto the actual context manager, because
-            # it will do the cleanup whenever it gets garbage collected, so
-            # we will also store that at the global level as well.
-            _CACERT_CTX = get_path("certifi", "cacert.pem")
-            _CACERT_PATH = str(_CACERT_CTX.__enter__())
-
-        return _CACERT_PATH
-
-
-except ImportError:
-    # This fallback will work for Python versions prior to 3.7 that lack the
-    # importlib.resources module but relies on the existing `where` function
-    # so won't address issues with environments like PyOxidizer that don't set
-    # __file__ on modules.
-    def read_text(_module, _path, encoding="ascii"):
-        with open(where(), "r", encoding=encoding) as data:
-            return data.read()
-
-    # If we don't have importlib.resources, then we will just do the old logic
-    # of assuming we're on the filesystem and munge the path directly.
-    def where():
-        f = os.path.dirname(__file__)
-
-        return os.path.join(f, "cacert.pem")
-
-
-def contents():
-    return read_text("certifi", "cacert.pem", encoding="ascii")
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/__init__.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/__init__.py
deleted file mode 100644
index c2bc5f9..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/__init__.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""
-Charset-Normalizer
-~~~~~~~~~~~~~~
-The Real First Universal Charset Detector.
-A library that helps you read text from an unknown charset encoding.
-Motivated by chardet, This package is trying to resolve the issue by taking a new approach.
-All IANA character set names for which the Python core library provides codecs are supported.
-
-Basic usage:
-   >>> from charset_normalizer import from_bytes
-   >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието трябва да бъде безплатно, поне що се отнася до началното и основното образование.'.encode('utf_8'))
-   >>> "utf_8" in results
-   True
-   >>> best_result = results.best()
-   >>> str(best_result)
-   'Bсеки човек има право на образование. Oбразованието трябва да бъде безплатно, поне що се отнася до началното и основното образование.'
-
-Others methods and usages are available - see the full documentation
-at <https://github.com/Ousret/charset_normalizer>.
-:copyright: (c) 2021 by Ahmed TAHRI
-:license: MIT, see LICENSE for more details.
-"""
-from charset_normalizer.api import from_fp, from_path, from_bytes, normalize
-from charset_normalizer.legacy import detect
-from charset_normalizer.version import __version__, VERSION
-from charset_normalizer.models import CharsetMatch, CharsetMatches
-
-# Backward-compatible v1 imports
-from charset_normalizer.models import CharsetNormalizerMatch
-import charset_normalizer.api as CharsetDetector
-
-CharsetNormalizerMatches = CharsetDetector
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/api.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/api.py
deleted file mode 100644
index 00cac06..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/api.py
+++ /dev/null
@@ -1,508 +0,0 @@
-from os.path import splitext, basename
-from typing import List, BinaryIO, Optional, Set, Union
-
-try:
-    from os import PathLike
-except ImportError:
-    PathLike = Union[str, "os.PathLike[str]"]  # type: ignore
-
-from charset_normalizer.constant import (
-    TOO_SMALL_SEQUENCE,
-    TOO_BIG_SEQUENCE,
-    IANA_SUPPORTED,
-)
-from charset_normalizer.md import mess_ratio
-from charset_normalizer.models import CharsetMatches, CharsetMatch
-from warnings import warn
-import logging
-
-from charset_normalizer.utils import (
-    any_specified_encoding,
-    is_multi_byte_encoding,
-    identify_sig_or_bom,
-    should_strip_sig_or_bom,
-    is_cp_similar,
-    iana_name,
-)
-from charset_normalizer.cd import (
-    coherence_ratio,
-    encoding_languages,
-    mb_encoding_languages,
-    merge_coherence_ratios,
-)
-
-logger = logging.getLogger("charset_normalizer")
-logger.setLevel(logging.DEBUG)
-
-handler = logging.StreamHandler()
-handler.setFormatter(logging.Formatter("%(asctime)s | %(levelname)s | %(message)s"))
-logger.addHandler(handler)
-
-
-def from_bytes(
-    sequences: bytes,
-    steps: int = 5,
-    chunk_size: int = 512,
-    threshold: float = 0.2,
-    cp_isolation: List[str] = None,
-    cp_exclusion: List[str] = None,
-    preemptive_behaviour: bool = True,
-    explain: bool = False,
-) -> CharsetMatches:
-    """
-    Given a raw bytes sequence, return the best possibles charset usable to render str objects.
-    If there is no results, it is a strong indicator that the source is binary/not text.
-    By default, the process will extract 5 blocs of 512o each to assess the mess and coherence of a given sequence.
-    And will give up a particular code page after 20% of measured mess. Those criteria are customizable at will.
-
-    The preemptive behavior DOES NOT replace the traditional detection workflow, it prioritize a particular code page
-    but never take it for granted. Can improve the performance.
-
-    You may want to focus your attention to some code page or/and not others, use cp_isolation and cp_exclusion for that
-    purpose.
-
-    This function will strip the SIG in the payload/sequence every time except on UTF-16, UTF-32.
-    """
-
-    if not explain:
-        logger.setLevel(logging.CRITICAL)
-    else:
-        logger.setLevel(logging.INFO)
-
-    length = len(sequences)  # type: int
-
-    if length == 0:
-        logger.warning(
-            "Given content is empty, stopping the process very early, returning empty utf_8 str match"
-        )
-        return CharsetMatches([CharsetMatch(sequences, "utf_8", 0.0, False, [], "")])
-
-    if cp_isolation is not None:
-        logger.warning(
-            "cp_isolation is set. use this flag for debugging purpose. "
-            "limited list of encoding allowed : %s.",
-            ", ".join(cp_isolation),
-        )
-        cp_isolation = [iana_name(cp, False) for cp in cp_isolation]
-    else:
-        cp_isolation = []
-
-    if cp_exclusion is not None:
-        logger.warning(
-            "cp_exclusion is set. use this flag for debugging purpose. "
-            "limited list of encoding excluded : %s.",
-            ", ".join(cp_exclusion),
-        )
-        cp_exclusion = [iana_name(cp, False) for cp in cp_exclusion]
-    else:
-        cp_exclusion = []
-
-    if length <= (chunk_size * steps):
-        logger.warning(
-            "override steps (%i) and chunk_size (%i) as content does not fit (%i byte(s) given) parameters.",
-            steps,
-            chunk_size,
-            length,
-        )
-        steps = 1
-        chunk_size = length
-
-    if steps > 1 and length / steps < chunk_size:
-        chunk_size = int(length / steps)
-
-    is_too_small_sequence = len(sequences) < TOO_SMALL_SEQUENCE  # type: bool
-    is_too_large_sequence = len(sequences) >= TOO_BIG_SEQUENCE  # type: bool
-
-    if is_too_small_sequence:
-        warn(
-            "Trying to detect encoding from a tiny portion of ({}) byte(s).".format(
-                length
-            )
-        )
-
-    prioritized_encodings = []  # type: List[str]
-
-    specified_encoding = (
-        any_specified_encoding(sequences) if preemptive_behaviour is True else None
-    )  # type: Optional[str]
-
-    if specified_encoding is not None:
-        prioritized_encodings.append(specified_encoding)
-        logger.info(
-            "Detected declarative mark in sequence. Priority +1 given for %s.",
-            specified_encoding,
-        )
-
-    tested = set()  # type: Set[str]
-    tested_but_hard_failure = []  # type: List[str]
-    tested_but_soft_failure = []  # type: List[str]
-
-    fallback_ascii = None  # type: Optional[CharsetMatch]
-    fallback_u8 = None  # type: Optional[CharsetMatch]
-    fallback_specified = None  # type: Optional[CharsetMatch]
-
-    single_byte_hard_failure_count = 0  # type: int
-    single_byte_soft_failure_count = 0  # type: int
-
-    results = CharsetMatches()  # type: CharsetMatches
-
-    sig_encoding, sig_payload = identify_sig_or_bom(sequences)
-
-    if sig_encoding is not None:
-        prioritized_encodings.append(sig_encoding)
-        logger.info(
-            "Detected a SIG or BOM mark on first %i byte(s). Priority +1 given for %s.",
-            len(sig_payload),
-            sig_encoding,
-        )
-
-    prioritized_encodings.append("ascii")
-
-    if "utf_8" not in prioritized_encodings:
-        prioritized_encodings.append("utf_8")
-
-    for encoding_iana in prioritized_encodings + IANA_SUPPORTED:
-
-        if cp_isolation and encoding_iana not in cp_isolation:
-            continue
-
-        if cp_exclusion and encoding_iana in cp_exclusion:
-            continue
-
-        if encoding_iana in tested:
-            continue
-
-        tested.add(encoding_iana)
-
-        decoded_payload = None  # type: Optional[str]
-        bom_or_sig_available = sig_encoding == encoding_iana  # type: bool
-        strip_sig_or_bom = bom_or_sig_available and should_strip_sig_or_bom(
-            encoding_iana
-        )  # type: bool
-
-        if encoding_iana in {"utf_16", "utf_32"} and bom_or_sig_available is False:
-            logger.info(
-                "Encoding %s wont be tested as-is because it require a BOM. Will try some sub-encoder LE/BE.",
-                encoding_iana,
-            )
-            continue
-
-        try:
-            is_multi_byte_decoder = is_multi_byte_encoding(encoding_iana)  # type: bool
-        except (ModuleNotFoundError, ImportError):
-            logger.debug(
-                "Encoding %s does not provide an IncrementalDecoder", encoding_iana
-            )
-            continue
-
-        try:
-            if is_too_large_sequence and is_multi_byte_decoder is False:
-                str(
-                    sequences[: int(50e4)]
-                    if strip_sig_or_bom is False
-                    else sequences[len(sig_payload) : int(50e4)],
-                    encoding=encoding_iana,
-                )
-            else:
-                decoded_payload = str(
-                    sequences
-                    if strip_sig_or_bom is False
-                    else sequences[len(sig_payload) :],
-                    encoding=encoding_iana,
-                )
-        except UnicodeDecodeError as e:
-            logger.warning(
-                "Code page %s does not fit given bytes sequence at ALL. %s",
-                encoding_iana,
-                str(e),
-            )
-            tested_but_hard_failure.append(encoding_iana)
-            if not is_multi_byte_decoder:
-                single_byte_hard_failure_count += 1
-            continue
-        except LookupError:
-            tested_but_hard_failure.append(encoding_iana)
-            if not is_multi_byte_decoder:
-                single_byte_hard_failure_count += 1
-            continue
-
-        similar_soft_failure_test = False  # type: bool
-
-        for encoding_soft_failed in tested_but_soft_failure:
-            if is_cp_similar(encoding_iana, encoding_soft_failed):
-                similar_soft_failure_test = True
-                break
-
-        if similar_soft_failure_test:
-            logger.warning(
-                "%s is deemed too similar to code page %s and was consider unsuited already. Continuing!",
-                encoding_iana,
-                encoding_soft_failed,
-            )
-            continue
-
-        r_ = range(
-            0 if bom_or_sig_available is False else len(sig_payload),
-            length,
-            int(length / steps),
-        )
-
-        multi_byte_bonus = (
-            is_multi_byte_decoder
-            and decoded_payload is not None
-            and len(decoded_payload) < length
-        )  # type: bool
-
-        if multi_byte_bonus:
-            logger.info(
-                "Code page %s is a multi byte encoding table and it appear that at least one character was encoded using n-bytes.",
-                encoding_iana,
-            )
-
-        max_chunk_gave_up = int(len(r_) / 4)  # type: int
-
-        if max_chunk_gave_up < 2:
-            max_chunk_gave_up = 2
-
-        early_stop_count = 0  # type: int
-
-        md_chunks = []  # type: List[str]
-        md_ratios = []
-
-        for i in r_:
-            cut_sequence = sequences[i : i + chunk_size]
-
-            if bom_or_sig_available and strip_sig_or_bom is False:
-                cut_sequence = sig_payload + cut_sequence
-
-            chunk = cut_sequence.decode(encoding_iana, errors="ignore")  # type: str
-
-            md_chunks.append(chunk)
-
-            md_ratios.append(mess_ratio(chunk, threshold))
-
-            if md_ratios[-1] >= threshold:
-                early_stop_count += 1
-
-            if (early_stop_count >= max_chunk_gave_up) or (
-                bom_or_sig_available and strip_sig_or_bom is False
-            ):
-                break
-
-        if md_ratios:
-            mean_mess_ratio = sum(md_ratios) / len(md_ratios)  # type: float
-        else:
-            mean_mess_ratio = 0.0
-
-        if mean_mess_ratio >= threshold or early_stop_count >= max_chunk_gave_up:
-            tested_but_soft_failure.append(encoding_iana)
-            if not is_multi_byte_decoder:
-                single_byte_soft_failure_count += 1
-            logger.warning(
-                "%s was excluded because of initial chaos probing. Gave up %i time(s). "
-                "Computed mean chaos is %f %%.",
-                encoding_iana,
-                early_stop_count,
-                round(mean_mess_ratio * 100, ndigits=3),
-            )
-            # Preparing those fallbacks in case we got nothing.
-            if encoding_iana in ["ascii", "utf_8", specified_encoding]:
-                fallback_entry = CharsetMatch(
-                    sequences, encoding_iana, threshold, False, [], decoded_payload
-                )
-                if encoding_iana == specified_encoding:
-                    fallback_specified = fallback_entry
-                elif encoding_iana == "ascii":
-                    fallback_ascii = fallback_entry
-                else:
-                    fallback_u8 = fallback_entry
-            continue
-
-        logger.info(
-            "%s passed initial chaos probing. Mean measured chaos is %f %%",
-            encoding_iana,
-            round(mean_mess_ratio * 100, ndigits=3),
-        )
-
-        if not is_multi_byte_decoder:
-            target_languages = encoding_languages(encoding_iana)  # type: List[str]
-        else:
-            target_languages = mb_encoding_languages(encoding_iana)
-
-        if target_languages:
-            logger.info(
-                "{} should target any language(s) of {}".format(
-                    encoding_iana, str(target_languages)
-                )
-            )
-
-        cd_ratios = []
-
-        for chunk in md_chunks:
-            chunk_languages = coherence_ratio(
-                chunk, 0.1, ",".join(target_languages) if target_languages else None
-            )
-
-            cd_ratios.append(chunk_languages)
-
-        cd_ratios_merged = merge_coherence_ratios(cd_ratios)
-
-        if cd_ratios_merged:
-            logger.info(
-                "We detected language {} using {}".format(
-                    cd_ratios_merged, encoding_iana
-                )
-            )
-
-        results.append(
-            CharsetMatch(
-                sequences,
-                encoding_iana,
-                mean_mess_ratio,
-                bom_or_sig_available,
-                cd_ratios_merged,
-                decoded_payload,
-            )
-        )
-
-        if (
-            encoding_iana in [specified_encoding, "ascii", "utf_8"]
-            and mean_mess_ratio < 0.1
-        ):
-            logger.info(
-                "%s is most likely the one. Stopping the process.", encoding_iana
-            )
-            return CharsetMatches([results[encoding_iana]])
-
-        if encoding_iana == sig_encoding:
-            logger.info(
-                "%s is most likely the one as we detected a BOM or SIG within the beginning of the sequence.",
-                encoding_iana,
-            )
-            return CharsetMatches([results[encoding_iana]])
-
-        if results[-1].languages:
-            logger.info(
-                "Using %s code page we detected the following languages: %s",
-                encoding_iana,
-                results[encoding_iana]._languages,
-            )
-
-    if len(results) == 0:
-        if fallback_u8 or fallback_ascii or fallback_specified:
-            logger.warning(
-                "Nothing got out of the detection process. Using ASCII/UTF-8/Specified fallback."
-            )
-
-        if fallback_specified:
-            logger.warning(
-                "%s will be used as a fallback match", fallback_specified.encoding
-            )
-            results.append(fallback_specified)
-        elif (fallback_u8 and fallback_ascii is None) or (
-            fallback_u8 and fallback_u8.fingerprint != fallback_ascii.fingerprint
-        ):
-            logger.warning("utf_8 will be used as a fallback match")
-            results.append(fallback_u8)
-        elif fallback_ascii:
-            logger.warning("ascii will be used as a fallback match")
-            results.append(fallback_ascii)
-
-    return results
-
-
-def from_fp(
-    fp: BinaryIO,
-    steps: int = 5,
-    chunk_size: int = 512,
-    threshold: float = 0.20,
-    cp_isolation: List[str] = None,
-    cp_exclusion: List[str] = None,
-    preemptive_behaviour: bool = True,
-    explain: bool = False,
-) -> CharsetMatches:
-    """
-    Same thing than the function from_bytes but using a file pointer that is already ready.
-    Will not close the file pointer.
-    """
-    return from_bytes(
-        fp.read(),
-        steps,
-        chunk_size,
-        threshold,
-        cp_isolation,
-        cp_exclusion,
-        preemptive_behaviour,
-        explain,
-    )
-
-
-def from_path(
-    path: PathLike,
-    steps: int = 5,
-    chunk_size: int = 512,
-    threshold: float = 0.20,
-    cp_isolation: List[str] = None,
-    cp_exclusion: List[str] = None,
-    preemptive_behaviour: bool = True,
-    explain: bool = False,
-) -> CharsetMatches:
-    """
-    Same thing than the function from_bytes but with one extra step. Opening and reading given file path in binary mode.
-    Can raise IOError.
-    """
-    with open(path, "rb") as fp:
-        return from_fp(
-            fp,
-            steps,
-            chunk_size,
-            threshold,
-            cp_isolation,
-            cp_exclusion,
-            preemptive_behaviour,
-            explain,
-        )
-
-
-def normalize(
-    path: PathLike,
-    steps: int = 5,
-    chunk_size: int = 512,
-    threshold: float = 0.20,
-    cp_isolation: List[str] = None,
-    cp_exclusion: List[str] = None,
-    preemptive_behaviour: bool = True,
-) -> CharsetMatch:
-    """
-    Take a (text-based) file path and try to create another file next to it, this time using UTF-8.
-    """
-    results = from_path(
-        path,
-        steps,
-        chunk_size,
-        threshold,
-        cp_isolation,
-        cp_exclusion,
-        preemptive_behaviour,
-    )
-
-    filename = basename(path)
-    target_extensions = list(splitext(filename))
-
-    if len(results) == 0:
-        raise IOError(
-            'Unable to normalize "{}", no encoding charset seems to fit.'.format(
-                filename
-            )
-        )
-
-    result = results.best()
-
-    target_extensions[0] += "-" + result.encoding  # type: ignore
-
-    with open(
-        "{}".format(path.replace(filename, "".join(target_extensions))), "wb"
-    ) as fp:
-        fp.write(result.output())  # type: ignore
-
-    return result  # type: ignore
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/assets/__init__.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/assets/__init__.py
deleted file mode 100644
index 698bca7..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/assets/__init__.py
+++ /dev/null
@@ -1,1220 +0,0 @@
-"""
-This submodule purpose is to load attached JSON asset.
-Will be loaded once per package import / python init.
-
-The file 'frequencies.json' is mandatory for language/coherence detection. Not having it will weaker considerably
-the core detection.
-"""
-from collections import OrderedDict
-
-
-FREQUENCIES = OrderedDict(
-    [
-        (
-            "English",
-            [
-                "e",
-                "a",
-                "t",
-                "i",
-                "o",
-                "n",
-                "s",
-                "r",
-                "h",
-                "l",
-                "d",
-                "c",
-                "u",
-                "m",
-                "f",
-                "p",
-                "g",
-                "w",
-                "y",
-                "b",
-                "v",
-                "k",
-                "x",
-                "j",
-                "z",
-                "q",
-            ],
-        ),
-        (
-            "German",
-            [
-                "e",
-                "n",
-                "i",
-                "r",
-                "s",
-                "t",
-                "a",
-                "d",
-                "h",
-                "u",
-                "l",
-                "g",
-                "o",
-                "c",
-                "m",
-                "b",
-                "f",
-                "k",
-                "w",
-                "z",
-                "p",
-                "v",
-                "ü",
-                "ä",
-                "ö",
-                "j",
-            ],
-        ),
-        (
-            "French",
-            [
-                "e",
-                "a",
-                "s",
-                "n",
-                "i",
-                "t",
-                "r",
-                "l",
-                "u",
-                "o",
-                "d",
-                "c",
-                "p",
-                "m",
-                "é",
-                "v",
-                "g",
-                "f",
-                "b",
-                "h",
-                "q",
-                "à",
-                "x",
-                "è",
-                "y",
-                "j",
-            ],
-        ),
-        (
-            "Dutch",
-            [
-                "e",
-                "n",
-                "a",
-                "i",
-                "r",
-                "t",
-                "o",
-                "d",
-                "s",
-                "l",
-                "g",
-                "h",
-                "v",
-                "m",
-                "u",
-                "k",
-                "c",
-                "p",
-                "b",
-                "w",
-                "j",
-                "z",
-                "f",
-                "y",
-                "x",
-                "ë",
-            ],
-        ),
-        (
-            "Italian",
-            [
-                "e",
-                "i",
-                "a",
-                "o",
-                "n",
-                "l",
-                "t",
-                "r",
-                "s",
-                "c",
-                "d",
-                "u",
-                "p",
-                "m",
-                "g",
-                "v",
-                "f",
-                "b",
-                "z",
-                "h",
-                "q",
-                "è",
-                "à",
-                "k",
-                "y",
-                "ò",
-            ],
-        ),
-        (
-            "Polish",
-            [
-                "a",
-                "i",
-                "o",
-                "e",
-                "n",
-                "r",
-                "z",
-                "w",
-                "s",
-                "c",
-                "t",
-                "k",
-                "y",
-                "d",
-                "p",
-                "m",
-                "u",
-                "l",
-                "j",
-                "ł",
-                "g",
-                "b",
-                "h",
-                "ą",
-                "ę",
-                "ó",
-            ],
-        ),
-        (
-            "Spanish",
-            [
-                "e",
-                "a",
-                "o",
-                "n",
-                "s",
-                "r",
-                "i",
-                "l",
-                "d",
-                "t",
-                "c",
-                "u",
-                "m",
-                "p",
-                "b",
-                "g",
-                "v",
-                "f",
-                "y",
-                "ó",
-                "h",
-                "q",
-                "í",
-                "j",
-                "z",
-                "á",
-            ],
-        ),
-        (
-            "Russian",
-            [
-                "о",
-                "а",
-                "е",
-                "и",
-                "н",
-                "с",
-                "т",
-                "р",
-                "в",
-                "л",
-                "к",
-                "м",
-                "д",
-                "п",
-                "у",
-                "г",
-                "я",
-                "ы",
-                "з",
-                "б",
-                "й",
-                "ь",
-                "ч",
-                "х",
-                "ж",
-                "ц",
-            ],
-        ),
-        (
-            "Japanese",
-            [
-                "の",
-                "に",
-                "る",
-                "た",
-                "は",
-                "ー",
-                "と",
-                "し",
-                "を",
-                "で",
-                "て",
-                "が",
-                "い",
-                "ン",
-                "れ",
-                "な",
-                "年",
-                "ス",
-                "っ",
-                "ル",
-                "か",
-                "ら",
-                "あ",
-                "さ",
-                "も",
-                "り",
-            ],
-        ),
-        (
-            "Portuguese",
-            [
-                "a",
-                "e",
-                "o",
-                "s",
-                "i",
-                "r",
-                "d",
-                "n",
-                "t",
-                "m",
-                "u",
-                "c",
-                "l",
-                "p",
-                "g",
-                "v",
-                "b",
-                "f",
-                "h",
-                "ã",
-                "q",
-                "é",
-                "ç",
-                "á",
-                "z",
-                "í",
-            ],
-        ),
-        (
-            "Swedish",
-            [
-                "e",
-                "a",
-                "n",
-                "r",
-                "t",
-                "s",
-                "i",
-                "l",
-                "d",
-                "o",
-                "m",
-                "k",
-                "g",
-                "v",
-                "h",
-                "f",
-                "u",
-                "p",
-                "ä",
-                "c",
-                "b",
-                "ö",
-                "å",
-                "y",
-                "j",
-                "x",
-            ],
-        ),
-        (
-            "Chinese",
-            [
-                "的",
-                "一",
-                "是",
-                "不",
-                "了",
-                "在",
-                "人",
-                "有",
-                "我",
-                "他",
-                "这",
-                "个",
-                "们",
-                "中",
-                "来",
-                "上",
-                "大",
-                "为",
-                "和",
-                "国",
-                "地",
-                "到",
-                "以",
-                "说",
-                "时",
-                "要",
-                "就",
-                "出",
-                "会",
-            ],
-        ),
-        (
-            "Ukrainian",
-            [
-                "о",
-                "а",
-                "н",
-                "і",
-                "и",
-                "р",
-                "в",
-                "т",
-                "е",
-                "с",
-                "к",
-                "л",
-                "у",
-                "д",
-                "м",
-                "п",
-                "з",
-                "я",
-                "ь",
-                "б",
-                "г",
-                "й",
-                "ч",
-                "х",
-                "ц",
-                "ї",
-            ],
-        ),
-        (
-            "Norwegian",
-            [
-                "e",
-                "r",
-                "n",
-                "t",
-                "a",
-                "s",
-                "i",
-                "o",
-                "l",
-                "d",
-                "g",
-                "k",
-                "m",
-                "v",
-                "f",
-                "p",
-                "u",
-                "b",
-                "h",
-                "å",
-                "y",
-                "j",
-                "ø",
-                "c",
-                "æ",
-                "w",
-            ],
-        ),
-        (
-            "Finnish",
-            [
-                "a",
-                "i",
-                "n",
-                "t",
-                "e",
-                "s",
-                "l",
-                "o",
-                "u",
-                "k",
-                "ä",
-                "m",
-                "r",
-                "v",
-                "j",
-                "h",
-                "p",
-                "y",
-                "d",
-                "ö",
-                "g",
-                "c",
-                "b",
-                "f",
-                "w",
-                "z",
-            ],
-        ),
-        (
-            "Vietnamese",
-            [
-                "n",
-                "h",
-                "t",
-                "i",
-                "c",
-                "g",
-                "a",
-                "o",
-                "u",
-                "m",
-                "l",
-                "r",
-                "à",
-                "đ",
-                "s",
-                "e",
-                "v",
-                "p",
-                "b",
-                "y",
-                "ư",
-                "d",
-                "á",
-                "k",
-                "ộ",
-                "ế",
-            ],
-        ),
-        (
-            "Czech",
-            [
-                "o",
-                "e",
-                "a",
-                "n",
-                "t",
-                "s",
-                "i",
-                "l",
-                "v",
-                "r",
-                "k",
-                "d",
-                "u",
-                "m",
-                "p",
-                "í",
-                "c",
-                "h",
-                "z",
-                "á",
-                "y",
-                "j",
-                "b",
-                "ě",
-                "é",
-                "ř",
-            ],
-        ),
-        (
-            "Hungarian",
-            [
-                "e",
-                "a",
-                "t",
-                "l",
-                "s",
-                "n",
-                "k",
-                "r",
-                "i",
-                "o",
-                "z",
-                "á",
-                "é",
-                "g",
-                "m",
-                "b",
-                "y",
-                "v",
-                "d",
-                "h",
-                "u",
-                "p",
-                "j",
-                "ö",
-                "f",
-                "c",
-            ],
-        ),
-        (
-            "Korean",
-            [
-                "이",
-                "다",
-                "에",
-                "의",
-                "는",
-                "로",
-                "하",
-                "을",
-                "가",
-                "고",
-                "지",
-                "서",
-                "한",
-                "은",
-                "기",
-                "으",
-                "년",
-                "대",
-                "사",
-                "시",
-                "를",
-                "리",
-                "도",
-                "인",
-                "스",
-                "일",
-            ],
-        ),
-        (
-            "Indonesian",
-            [
-                "a",
-                "n",
-                "e",
-                "i",
-                "r",
-                "t",
-                "u",
-                "s",
-                "d",
-                "k",
-                "m",
-                "l",
-                "g",
-                "p",
-                "b",
-                "o",
-                "h",
-                "y",
-                "j",
-                "c",
-                "w",
-                "f",
-                "v",
-                "z",
-                "x",
-                "q",
-            ],
-        ),
-        (
-            "Turkish",
-            [
-                "a",
-                "e",
-                "i",
-                "n",
-                "r",
-                "l",
-                "ı",
-                "k",
-                "d",
-                "t",
-                "s",
-                "m",
-                "y",
-                "u",
-                "o",
-                "b",
-                "ü",
-                "ş",
-                "v",
-                "g",
-                "z",
-                "h",
-                "c",
-                "p",
-                "ç",
-                "ğ",
-            ],
-        ),
-        (
-            "Romanian",
-            [
-                "e",
-                "i",
-                "a",
-                "r",
-                "n",
-                "t",
-                "u",
-                "l",
-                "o",
-                "c",
-                "s",
-                "d",
-                "p",
-                "m",
-                "ă",
-                "f",
-                "v",
-                "î",
-                "g",
-                "b",
-                "ș",
-                "ț",
-                "z",
-                "h",
-                "â",
-                "j",
-            ],
-        ),
-        (
-            "Farsi",
-            [
-                "ا",
-                "ی",
-                "ر",
-                "د",
-                "ن",
-                "ه",
-                "و",
-                "م",
-                "ت",
-                "ب",
-                "س",
-                "ل",
-                "ک",
-                "ش",
-                "ز",
-                "ف",
-                "گ",
-                "ع",
-                "خ",
-                "ق",
-                "ج",
-                "آ",
-                "پ",
-                "ح",
-                "ط",
-                "ص",
-            ],
-        ),
-        (
-            "Arabic",
-            [
-                "ا",
-                "ل",
-                "ي",
-                "م",
-                "و",
-                "ن",
-                "ر",
-                "ت",
-                "ب",
-                "ة",
-                "ع",
-                "د",
-                "س",
-                "ف",
-                "ه",
-                "ك",
-                "ق",
-                "أ",
-                "ح",
-                "ج",
-                "ش",
-                "ط",
-                "ص",
-                "ى",
-                "خ",
-                "إ",
-            ],
-        ),
-        (
-            "Danish",
-            [
-                "e",
-                "r",
-                "n",
-                "t",
-                "a",
-                "i",
-                "s",
-                "d",
-                "l",
-                "o",
-                "g",
-                "m",
-                "k",
-                "f",
-                "v",
-                "u",
-                "b",
-                "h",
-                "p",
-                "å",
-                "y",
-                "ø",
-                "æ",
-                "c",
-                "j",
-                "w",
-            ],
-        ),
-        (
-            "Serbian",
-            [
-                "а",
-                "и",
-                "о",
-                "е",
-                "н",
-                "р",
-                "с",
-                "у",
-                "т",
-                "к",
-                "ј",
-                "в",
-                "д",
-                "м",
-                "п",
-                "л",
-                "г",
-                "з",
-                "б",
-                "a",
-                "i",
-                "e",
-                "o",
-                "n",
-                "ц",
-                "ш",
-            ],
-        ),
-        (
-            "Lithuanian",
-            [
-                "i",
-                "a",
-                "s",
-                "o",
-                "r",
-                "e",
-                "t",
-                "n",
-                "u",
-                "k",
-                "m",
-                "l",
-                "p",
-                "v",
-                "d",
-                "j",
-                "g",
-                "ė",
-                "b",
-                "y",
-                "ų",
-                "š",
-                "ž",
-                "c",
-                "ą",
-                "į",
-            ],
-        ),
-        (
-            "Slovene",
-            [
-                "e",
-                "a",
-                "i",
-                "o",
-                "n",
-                "r",
-                "s",
-                "l",
-                "t",
-                "j",
-                "v",
-                "k",
-                "d",
-                "p",
-                "m",
-                "u",
-                "z",
-                "b",
-                "g",
-                "h",
-                "č",
-                "c",
-                "š",
-                "ž",
-                "f",
-                "y",
-            ],
-        ),
-        (
-            "Slovak",
-            [
-                "o",
-                "a",
-                "e",
-                "n",
-                "i",
-                "r",
-                "v",
-                "t",
-                "s",
-                "l",
-                "k",
-                "d",
-                "m",
-                "p",
-                "u",
-                "c",
-                "h",
-                "j",
-                "b",
-                "z",
-                "á",
-                "y",
-                "ý",
-                "í",
-                "č",
-                "é",
-            ],
-        ),
-        (
-            "Hebrew",
-            [
-                "י",
-                "ו",
-                "ה",
-                "ל",
-                "ר",
-                "ב",
-                "ת",
-                "מ",
-                "א",
-                "ש",
-                "נ",
-                "ע",
-                "ם",
-                "ד",
-                "ק",
-                "ח",
-                "פ",
-                "ס",
-                "כ",
-                "ג",
-                "ט",
-                "צ",
-                "ן",
-                "ז",
-                "ך",
-            ],
-        ),
-        (
-            "Bulgarian",
-            [
-                "а",
-                "и",
-                "о",
-                "е",
-                "н",
-                "т",
-                "р",
-                "с",
-                "в",
-                "л",
-                "к",
-                "д",
-                "п",
-                "м",
-                "з",
-                "г",
-                "я",
-                "ъ",
-                "у",
-                "б",
-                "ч",
-                "ц",
-                "й",
-                "ж",
-                "щ",
-                "х",
-            ],
-        ),
-        (
-            "Croatian",
-            [
-                "a",
-                "i",
-                "o",
-                "e",
-                "n",
-                "r",
-                "j",
-                "s",
-                "t",
-                "u",
-                "k",
-                "l",
-                "v",
-                "d",
-                "m",
-                "p",
-                "g",
-                "z",
-                "b",
-                "c",
-                "č",
-                "h",
-                "š",
-                "ž",
-                "ć",
-                "f",
-            ],
-        ),
-        (
-            "Hindi",
-            [
-                "क",
-                "र",
-                "स",
-                "न",
-                "त",
-                "म",
-                "ह",
-                "प",
-                "य",
-                "ल",
-                "व",
-                "ज",
-                "द",
-                "ग",
-                "ब",
-                "श",
-                "ट",
-                "अ",
-                "ए",
-                "थ",
-                "भ",
-                "ड",
-                "च",
-                "ध",
-                "ष",
-                "इ",
-            ],
-        ),
-        (
-            "Estonian",
-            [
-                "a",
-                "i",
-                "e",
-                "s",
-                "t",
-                "l",
-                "u",
-                "n",
-                "o",
-                "k",
-                "r",
-                "d",
-                "m",
-                "v",
-                "g",
-                "p",
-                "j",
-                "h",
-                "ä",
-                "b",
-                "õ",
-                "ü",
-                "f",
-                "c",
-                "ö",
-                "y",
-            ],
-        ),
-        (
-            "Simple English",
-            [
-                "e",
-                "a",
-                "t",
-                "i",
-                "o",
-                "n",
-                "s",
-                "r",
-                "h",
-                "l",
-                "d",
-                "c",
-                "m",
-                "u",
-                "f",
-                "p",
-                "g",
-                "w",
-                "b",
-                "y",
-                "v",
-                "k",
-                "j",
-                "x",
-                "z",
-                "q",
-            ],
-        ),
-        (
-            "Thai",
-            [
-                "า",
-                "น",
-                "ร",
-                "อ",
-                "ก",
-                "เ",
-                "ง",
-                "ม",
-                "ย",
-                "ล",
-                "ว",
-                "ด",
-                "ท",
-                "ส",
-                "ต",
-                "ะ",
-                "ป",
-                "บ",
-                "ค",
-                "ห",
-                "แ",
-                "จ",
-                "พ",
-                "ช",
-                "ข",
-                "ใ",
-            ],
-        ),
-        (
-            "Greek",
-            [
-                "α",
-                "τ",
-                "ο",
-                "ι",
-                "ε",
-                "ν",
-                "ρ",
-                "σ",
-                "κ",
-                "η",
-                "π",
-                "ς",
-                "υ",
-                "μ",
-                "λ",
-                "ί",
-                "ό",
-                "ά",
-                "γ",
-                "έ",
-                "δ",
-                "ή",
-                "ω",
-                "χ",
-                "θ",
-                "ύ",
-            ],
-        ),
-        (
-            "Tamil",
-            [
-                "க",
-                "த",
-                "ப",
-                "ட",
-                "ர",
-                "ம",
-                "ல",
-                "ன",
-                "வ",
-                "ற",
-                "ய",
-                "ள",
-                "ச",
-                "ந",
-                "இ",
-                "ண",
-                "அ",
-                "ஆ",
-                "ழ",
-                "ங",
-                "எ",
-                "உ",
-                "ஒ",
-                "ஸ",
-            ],
-        ),
-        (
-            "Classical Chinese",
-            [
-                "之",
-                "年",
-                "為",
-                "也",
-                "以",
-                "一",
-                "人",
-                "其",
-                "者",
-                "國",
-                "有",
-                "二",
-                "十",
-                "於",
-                "曰",
-                "三",
-                "不",
-                "大",
-                "而",
-                "子",
-                "中",
-                "五",
-                "四",
-            ],
-        ),
-    ]
-)
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/cd.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/cd.py
deleted file mode 100644
index c194a2e..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/cd.py
+++ /dev/null
@@ -1,291 +0,0 @@
-from codecs import IncrementalDecoder
-from functools import lru_cache
-from typing import List, Set, Optional, Tuple, Dict
-import importlib
-
-from charset_normalizer.models import CoherenceMatches
-from charset_normalizer.utils import (
-    unicode_range,
-    is_unicode_range_secondary,
-    is_multi_byte_encoding,
-)
-from charset_normalizer.md import is_suspiciously_successive_range
-from charset_normalizer.assets import FREQUENCIES
-from collections import Counter
-
-
-def encoding_unicode_range(iana_name: str) -> List[str]:
-    """
-    Return associated unicode ranges in a single byte code page.
-    """
-    if is_multi_byte_encoding(iana_name):
-        raise IOError("Function not supported on multi-byte code page")
-
-    decoder = importlib.import_module("encodings.{}".format(iana_name)).IncrementalDecoder  # type: ignore
-
-    p = decoder(errors="ignore")  # type: IncrementalDecoder
-    seen_ranges = set()  # type: Set[str]
-
-    for i in range(48, 255):
-        chunk = p.decode(bytes([i]))  # type: str
-
-        if chunk:
-            character_range = unicode_range(chunk)  # type: Optional[str]
-
-            if character_range is None:
-                continue
-
-            if is_unicode_range_secondary(character_range) is False:
-                seen_ranges.add(character_range)
-
-    return sorted(list(seen_ranges))
-
-
-def unicode_range_languages(primary_range: str) -> List[str]:
-    """
-    Return inferred languages used with a unicode range.
-    """
-    languages = []  # type: List[str]
-
-    for language, characters in FREQUENCIES.items():
-        for character in characters:
-            if unicode_range(character) == primary_range:
-                languages.append(language)
-                break
-
-    return languages
-
-
-@lru_cache()
-def encoding_languages(iana_name: str) -> List[str]:
-    """
-    Single-byte encoding language association. Some code page are heavily linked to particular language(s).
-    This function does the correspondence.
-    """
-    unicode_ranges = encoding_unicode_range(iana_name)  # type: List[str]
-    primary_range = None  # type: Optional[str]
-
-    for specified_range in unicode_ranges:
-        if "Latin" not in specified_range:
-            primary_range = specified_range
-            break
-
-    if primary_range is None:
-        return ["Latin Based"]
-
-    return unicode_range_languages(primary_range)
-
-
-def mb_encoding_languages(iana_name: str) -> List[str]:
-    """
-    Multi-byte encoding language association. Some code page are heavily linked to particular language(s).
-    This function does the correspondence.
-    """
-    if (
-        iana_name.startswith("shift_")
-        or iana_name.startswith("iso2022_jp")
-        or iana_name.startswith("euc_j")
-        or iana_name in {"cp932"}
-    ):
-        return ["Japanese"]
-    if iana_name.startswith("gb") or iana_name in {"big5", "cp950", "big5hkscs"}:
-        return ["Chinese", "Classical Chinese"]
-    if iana_name.startswith("iso2022_kr") or iana_name in {"johab", "cp949", "euc_kr"}:
-        return ["Korean"]
-
-    return []
-
-
-def alphabet_languages(characters: List[str]) -> List[str]:
-    """
-    Return associated languages associated to given characters.
-    """
-    languages = []  # type: List[str]
-
-    for language, language_characters in FREQUENCIES.items():
-        character_match_count = 0  # type: int
-        character_count = len(language_characters)  # type: int
-
-        for character in language_characters:
-            if character in characters:
-                character_match_count += 1
-
-        if character_match_count / character_count >= 0.2:
-            languages.append(language)
-
-    return languages
-
-
-def characters_popularity_compare(
-    language: str, ordered_characters: List[str]
-) -> float:
-    """
-    Determine if a ordered characters list (by occurrence from most appearance to rarest) match a particular language.
-    The result is a ratio between 0. (absolutely no correspondence) and 1. (near perfect fit).
-    Beware that is function is not strict on the match in order to ease the detection. (Meaning close match is 1.)
-    """
-    if language not in FREQUENCIES:
-        raise ValueError("{} not available".format(language))
-
-    character_approved_count = 0  # type: int
-
-    for character in ordered_characters:
-        if character not in FREQUENCIES[language]:
-            continue
-
-        characters_before_source = FREQUENCIES[language][
-            0 : FREQUENCIES[language].index(character)
-        ]  # type: List[str]
-        characters_after_source = FREQUENCIES[language][
-            FREQUENCIES[language].index(character) :
-        ]  # type: List[str]
-
-        characters_before = ordered_characters[
-            0 : ordered_characters.index(character)
-        ]  # type: List[str]
-        characters_after = ordered_characters[
-            ordered_characters.index(character) :
-        ]  # type: List[str]
-
-        before_match_count = [
-            e in characters_before for e in characters_before_source
-        ].count(
-            True
-        )  # type: int
-        after_match_count = [
-            e in characters_after for e in characters_after_source
-        ].count(
-            True
-        )  # type: int
-
-        if len(characters_before_source) == 0 and before_match_count <= 4:
-            character_approved_count += 1
-            continue
-
-        if len(characters_after_source) == 0 and after_match_count <= 4:
-            character_approved_count += 1
-            continue
-
-        if (
-            before_match_count / len(characters_before_source) >= 0.4
-            or after_match_count / len(characters_after_source) >= 0.4
-        ):
-            character_approved_count += 1
-            continue
-
-    return character_approved_count / len(ordered_characters)
-
-
-def alpha_unicode_split(decoded_sequence: str) -> List[str]:
-    """
-    Given a decoded text sequence, return a list of str. Unicode range / alphabet separation.
-    Ex. a text containing English/Latin with a bit a Hebrew will return two items in the resulting list;
-    One containing the latin letters and the other hebrew.
-    """
-    layers = {}  # type: Dict[str, str]
-
-    for character in decoded_sequence:
-        if character.isalpha() is False:
-            continue
-
-        character_range = unicode_range(character)  # type: str
-
-        layer_target_range = None  # type: Optional[str]
-
-        for discovered_range in layers:
-            if (
-                is_suspiciously_successive_range(discovered_range, character_range)
-                is False
-            ):
-                layer_target_range = discovered_range
-                break
-
-        if layer_target_range is None:
-            layer_target_range = character_range
-
-        if layer_target_range not in layers:
-            layers[layer_target_range] = character.lower()
-            continue
-
-        layers[layer_target_range] += character.lower()
-
-    return list(layers.values())
-
-
-def merge_coherence_ratios(results: List[CoherenceMatches]) -> CoherenceMatches:
-    """
-    This function merge results previously given by the function coherence_ratio.
-    The return type is the same as coherence_ratio.
-    """
-    per_language_ratios = {}  # type: Dict[str, List[float]]
-    merge = []  # type: CoherenceMatches
-
-    for result in results:
-        for sub_result in result:
-            language, ratio = sub_result
-            if language not in per_language_ratios:
-                per_language_ratios[language] = [ratio]
-                continue
-            per_language_ratios[language].append(ratio)
-
-    for language in per_language_ratios:
-        merge.append(
-            (
-                language,
-                round(
-                    sum(per_language_ratios[language])
-                    / len(per_language_ratios[language]),
-                    4,
-                ),
-            )
-        )
-
-    return sorted(merge, key=lambda x: x[1], reverse=True)
-
-
-@lru_cache(maxsize=2048)
-def coherence_ratio(
-    decoded_sequence: str, threshold: float = 0.1, lg_inclusion: Optional[str] = None
-) -> CoherenceMatches:
-    """
-    Detect ANY language that can be identified in given sequence. The sequence will be analysed by layers.
-    A layer = Character extraction by alphabets/ranges.
-    """
-
-    results = []  # type: List[Tuple[str, float]]
-
-    sufficient_match_count = 0  # type: int
-
-    if lg_inclusion is not None:
-        lg_inclusion = lg_inclusion.split(",")
-
-    if lg_inclusion is not None and "Latin Based" in lg_inclusion:
-        lg_inclusion.remove("Latin Based")
-
-    for layer in alpha_unicode_split(decoded_sequence):
-        sequence_frequencies = Counter(layer)  # type: Counter
-        most_common = sequence_frequencies.most_common()
-
-        character_count = sum([o for c, o in most_common])  # type: int
-
-        if character_count <= 32:
-            continue
-
-        popular_character_ordered = [c for c, o in most_common]  # type: List[str]
-
-        for language in lg_inclusion or alphabet_languages(popular_character_ordered):
-            ratio = characters_popularity_compare(
-                language, popular_character_ordered
-            )  # type: float
-
-            if ratio < threshold:
-                continue
-            elif ratio >= 0.8:
-                sufficient_match_count += 1
-
-            results.append((language, round(ratio, 4)))
-
-            if sufficient_match_count >= 3:
-                break
-
-    return sorted(results, key=lambda x: x[1], reverse=True)
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/cli/__init__.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/cli/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/cli/normalizer.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/cli/normalizer.py
deleted file mode 100644
index 40da9da..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/cli/normalizer.py
+++ /dev/null
@@ -1,279 +0,0 @@
-import argparse
-import sys
-from os.path import abspath
-from json import dumps
-
-from charset_normalizer import from_fp
-from charset_normalizer.models import CliDetectionResult
-from charset_normalizer.version import __version__
-
-from platform import python_version
-
-
-def query_yes_no(question, default="yes"):
-    """Ask a yes/no question via input() and return their answer.
-
-    "question" is a string that is presented to the user.
-    "default" is the presumed answer if the user just hits <Enter>.
-        It must be "yes" (the default), "no" or None (meaning
-        an answer is required of the user).
-
-    The "answer" return value is True for "yes" or False for "no".
-
-    Credit goes to (c) https://stackoverflow.com/questions/3041986/apt-command-line-interface-like-yes-no-input
-    """
-    valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
-    if default is None:
-        prompt = " [y/n] "
-    elif default == "yes":
-        prompt = " [Y/n] "
-    elif default == "no":
-        prompt = " [y/N] "
-    else:
-        raise ValueError("invalid default answer: '%s'" % default)
-
-    while True:
-        sys.stdout.write(question + prompt)
-        choice = input().lower()
-        if default is not None and choice == "":
-            return valid[default]
-        elif choice in valid:
-            return valid[choice]
-        else:
-            sys.stdout.write("Please respond with 'yes' or 'no' " "(or 'y' or 'n').\n")
-
-
-def cli_detect(argv=None):
-    """
-    CLI assistant using ARGV and ArgumentParser
-    :param argv:
-    :return: 0 if everything is fine, anything else equal trouble
-    """
-    parser = argparse.ArgumentParser(
-        description="The Real First Universal Charset Detector. "
-        "Discover originating encoding used on text file. "
-        "Normalize text to unicode."
-    )
-
-    parser.add_argument(
-        "files", type=argparse.FileType("rb"), nargs="+", help="File(s) to be analysed"
-    )
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        default=False,
-        dest="verbose",
-        help="Display complementary information about file if any. Stdout will contain logs about the detection process.",
-    )
-    parser.add_argument(
-        "-a",
-        "--with-alternative",
-        action="store_true",
-        default=False,
-        dest="alternatives",
-        help="Output complementary possibilities if any. Top-level JSON WILL be a list.",
-    )
-    parser.add_argument(
-        "-n",
-        "--normalize",
-        action="store_true",
-        default=False,
-        dest="normalize",
-        help="Permit to normalize input file. If not set, program does not write anything.",
-    )
-    parser.add_argument(
-        "-m",
-        "--minimal",
-        action="store_true",
-        default=False,
-        dest="minimal",
-        help="Only output the charset detected to STDOUT. Disabling JSON output.",
-    )
-    parser.add_argument(
-        "-r",
-        "--replace",
-        action="store_true",
-        default=False,
-        dest="replace",
-        help="Replace file when trying to normalize it instead of creating a new one.",
-    )
-    parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        dest="force",
-        help="Replace file without asking if you are sure, use this flag with caution.",
-    )
-    parser.add_argument(
-        "-t",
-        "--threshold",
-        action="store",
-        default=0.1,
-        type=float,
-        dest="threshold",
-        help="Define a custom maximum amount of chaos allowed in decoded content. 0. <= chaos <= 1.",
-    )
-    parser.add_argument(
-        "--version",
-        action="version",
-        version="Charset-Normalizer {} - Python {}".format(
-            __version__, python_version()
-        ),
-        help="Show version information and exit.",
-    )
-
-    args = parser.parse_args(argv)
-
-    if args.replace is True and args.normalize is False:
-        print("Use --replace in addition of --normalize only.", file=sys.stderr)
-        return 1
-
-    if args.force is True and args.replace is False:
-        print("Use --force in addition of --replace only.", file=sys.stderr)
-        return 1
-
-    if args.threshold < 0.0 or args.threshold > 1.0:
-        print("--threshold VALUE should be between 0. AND 1.", file=sys.stderr)
-        return 1
-
-    x_ = []
-
-    for my_file in args.files:
-
-        matches = from_fp(my_file, threshold=args.threshold, explain=args.verbose)
-
-        if len(matches) == 0:
-            print(
-                'Unable to identify originating encoding for "{}". {}'.format(
-                    my_file.name,
-                    "Maybe try increasing maximum amount of chaos."
-                    if args.threshold < 1.0
-                    else "",
-                ),
-                file=sys.stderr,
-            )
-            x_.append(
-                CliDetectionResult(
-                    abspath(my_file.name),
-                    None,
-                    [],
-                    [],
-                    "Unknown",
-                    [],
-                    False,
-                    1.0,
-                    0.0,
-                    None,
-                    True,
-                )
-            )
-        else:
-
-            r_ = matches.best()
-            p_ = r_.first()
-
-            x_.append(
-                CliDetectionResult(
-                    abspath(my_file.name),
-                    p_.encoding,
-                    p_.encoding_aliases,
-                    [cp for cp in p_.could_be_from_charset if cp != p_.encoding],
-                    p_.language,
-                    p_.alphabets,
-                    p_.bom,
-                    p_.percent_chaos,
-                    p_.percent_coherence,
-                    None,
-                    True,
-                )
-            )
-
-            if len(matches) > 1 and args.alternatives:
-                for el in matches:
-                    if el != p_:
-                        x_.append(
-                            CliDetectionResult(
-                                abspath(my_file.name),
-                                el.encoding,
-                                el.encoding_aliases,
-                                [
-                                    cp
-                                    for cp in el.could_be_from_charset
-                                    if cp != el.encoding
-                                ],
-                                el.language,
-                                el.alphabets,
-                                el.bom,
-                                el.percent_chaos,
-                                el.percent_coherence,
-                                None,
-                                False,
-                            )
-                        )
-
-            if args.normalize is True:
-
-                if p_.encoding.startswith("utf") is True:
-                    print(
-                        '"{}" file does not need to be normalized, as it already came from unicode.'.format(
-                            my_file.name
-                        ),
-                        file=sys.stderr,
-                    )
-                    if my_file.closed is False:
-                        my_file.close()
-                    continue
-
-                o_ = my_file.name.split(".")  # type: list[str]
-
-                if args.replace is False:
-                    o_.insert(-1, p_.encoding)
-                    if my_file.closed is False:
-                        my_file.close()
-                else:
-                    if (
-                        args.force is False
-                        and query_yes_no(
-                            'Are you sure to normalize "{}" by replacing it ?'.format(
-                                my_file.name
-                            ),
-                            "no",
-                        )
-                        is False
-                    ):
-                        if my_file.closed is False:
-                            my_file.close()
-                        continue
-
-                try:
-                    x_[0].unicode_path = abspath("./{}".format(".".join(o_)))
-
-                    with open(x_[0].unicode_path, "w", encoding="utf-8") as fp:
-                        fp.write(str(p_))
-                except IOError as e:
-                    print(str(e), file=sys.stderr)
-                    if my_file.closed is False:
-                        my_file.close()
-                    return 2
-
-        if my_file.closed is False:
-            my_file.close()
-
-    if args.minimal is False:
-        print(
-            dumps(
-                [el.__dict__ for el in x_] if len(x_) > 1 else x_[0].__dict__,
-                ensure_ascii=True,
-                indent=4,
-            )
-        )
-    else:
-        print(", ".join([el.encoding for el in x_]))
-
-    return 0
-
-
-if __name__ == "__main__":
-    cli_detect()
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/constant.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/constant.py
deleted file mode 100644
index 1cc5a97..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/constant.py
+++ /dev/null
@@ -1,471 +0,0 @@
-from codecs import BOM_UTF8, BOM_UTF16_BE, BOM_UTF16_LE, BOM_UTF32_BE, BOM_UTF32_LE
-from typing import Dict, List, Union
-from encodings.aliases import aliases
-from re import compile as re_compile, IGNORECASE
-from collections import OrderedDict
-
-# Contain for each eligible encoding a list of/item bytes SIG/BOM
-ENCODING_MARKS = OrderedDict(
-    [
-        ("utf_8", BOM_UTF8),
-        (
-            "utf_7",
-            [
-                b"\x2b\x2f\x76\x38",
-                b"\x2b\x2f\x76\x39",
-                b"\x2b\x2f\x76\x2b",
-                b"\x2b\x2f\x76\x2f",
-                b"\x2b\x2f\x76\x38\x2d",
-            ],
-        ),
-        ("gb18030", b"\x84\x31\x95\x33"),
-        ("utf_32", [BOM_UTF32_BE, BOM_UTF32_LE]),
-        ("utf_16", [BOM_UTF16_BE, BOM_UTF16_LE]),
-    ]
-)  # type: Dict[str, Union[bytes, List[bytes]]]
-
-TOO_SMALL_SEQUENCE = 32  # type: int
-TOO_BIG_SEQUENCE = int(10e6)  # type: int
-
-UTF8_MAXIMAL_ALLOCATION = 1112064  # type: int
-
-UNICODE_RANGES_COMBINED = {
-    "Control character": range(0, 31 + 1),
-    "Basic Latin": range(32, 127 + 1),
-    "Latin-1 Supplement": range(128, 255 + 1),
-    "Latin Extended-A": range(256, 383 + 1),
-    "Latin Extended-B": range(384, 591 + 1),
-    "IPA Extensions": range(592, 687 + 1),
-    "Spacing Modifier Letters": range(688, 767 + 1),
-    "Combining Diacritical Marks": range(768, 879 + 1),
-    "Greek and Coptic": range(880, 1023 + 1),
-    "Cyrillic": range(1024, 1279 + 1),
-    "Cyrillic Supplement": range(1280, 1327 + 1),
-    "Armenian": range(1328, 1423 + 1),
-    "Hebrew": range(1424, 1535 + 1),
-    "Arabic": range(1536, 1791 + 1),
-    "Syriac": range(1792, 1871 + 1),
-    "Arabic Supplement": range(1872, 1919 + 1),
-    "Thaana": range(1920, 1983 + 1),
-    "NKo": range(1984, 2047 + 1),
-    "Samaritan": range(2048, 2111 + 1),
-    "Mandaic": range(2112, 2143 + 1),
-    "Syriac Supplement": range(2144, 2159 + 1),
-    "Arabic Extended-A": range(2208, 2303 + 1),
-    "Devanagari": range(2304, 2431 + 1),
-    "Bengali": range(2432, 2559 + 1),
-    "Gurmukhi": range(2560, 2687 + 1),
-    "Gujarati": range(2688, 2815 + 1),
-    "Oriya": range(2816, 2943 + 1),
-    "Tamil": range(2944, 3071 + 1),
-    "Telugu": range(3072, 3199 + 1),
-    "Kannada": range(3200, 3327 + 1),
-    "Malayalam": range(3328, 3455 + 1),
-    "Sinhala": range(3456, 3583 + 1),
-    "Thai": range(3584, 3711 + 1),
-    "Lao": range(3712, 3839 + 1),
-    "Tibetan": range(3840, 4095 + 1),
-    "Myanmar": range(4096, 4255 + 1),
-    "Georgian": range(4256, 4351 + 1),
-    "Hangul Jamo": range(4352, 4607 + 1),
-    "Ethiopic": range(4608, 4991 + 1),
-    "Ethiopic Supplement": range(4992, 5023 + 1),
-    "Cherokee": range(5024, 5119 + 1),
-    "Unified Canadian Aboriginal Syllabics": range(5120, 5759 + 1),
-    "Ogham": range(5760, 5791 + 1),
-    "Runic": range(5792, 5887 + 1),
-    "Tagalog": range(5888, 5919 + 1),
-    "Hanunoo": range(5920, 5951 + 1),
-    "Buhid": range(5952, 5983 + 1),
-    "Tagbanwa": range(5984, 6015 + 1),
-    "Khmer": range(6016, 6143 + 1),
-    "Mongolian": range(6144, 6319 + 1),
-    "Unified Canadian Aboriginal Syllabics Extended": range(6320, 6399 + 1),
-    "Limbu": range(6400, 6479 + 1),
-    "Tai Le": range(6480, 6527 + 1),
-    "New Tai Lue": range(6528, 6623 + 1),
-    "Khmer Symbols": range(6624, 6655 + 1),
-    "Buginese": range(6656, 6687 + 1),
-    "Tai Tham": range(6688, 6831 + 1),
-    "Combining Diacritical Marks Extended": range(6832, 6911 + 1),
-    "Balinese": range(6912, 7039 + 1),
-    "Sundanese": range(7040, 7103 + 1),
-    "Batak": range(7104, 7167 + 1),
-    "Lepcha": range(7168, 7247 + 1),
-    "Ol Chiki": range(7248, 7295 + 1),
-    "Cyrillic Extended C": range(7296, 7311 + 1),
-    "Sundanese Supplement": range(7360, 7375 + 1),
-    "Vedic Extensions": range(7376, 7423 + 1),
-    "Phonetic Extensions": range(7424, 7551 + 1),
-    "Phonetic Extensions Supplement": range(7552, 7615 + 1),
-    "Combining Diacritical Marks Supplement": range(7616, 7679 + 1),
-    "Latin Extended Additional": range(7680, 7935 + 1),
-    "Greek Extended": range(7936, 8191 + 1),
-    "General Punctuation": range(8192, 8303 + 1),
-    "Superscripts and Subscripts": range(8304, 8351 + 1),
-    "Currency Symbols": range(8352, 8399 + 1),
-    "Combining Diacritical Marks for Symbols": range(8400, 8447 + 1),
-    "Letterlike Symbols": range(8448, 8527 + 1),
-    "Number Forms": range(8528, 8591 + 1),
-    "Arrows": range(8592, 8703 + 1),
-    "Mathematical Operators": range(8704, 8959 + 1),
-    "Miscellaneous Technical": range(8960, 9215 + 1),
-    "Control Pictures": range(9216, 9279 + 1),
-    "Optical Character Recognition": range(9280, 9311 + 1),
-    "Enclosed Alphanumerics": range(9312, 9471 + 1),
-    "Box Drawing": range(9472, 9599 + 1),
-    "Block Elements": range(9600, 9631 + 1),
-    "Geometric Shapes": range(9632, 9727 + 1),
-    "Miscellaneous Symbols": range(9728, 9983 + 1),
-    "Dingbats": range(9984, 10175 + 1),
-    "Miscellaneous Mathematical Symbols-A": range(10176, 10223 + 1),
-    "Supplemental Arrows-A": range(10224, 10239 + 1),
-    "Braille Patterns": range(10240, 10495 + 1),
-    "Supplemental Arrows-B": range(10496, 10623 + 1),
-    "Miscellaneous Mathematical Symbols-B": range(10624, 10751 + 1),
-    "Supplemental Mathematical Operators": range(10752, 11007 + 1),
-    "Miscellaneous Symbols and Arrows": range(11008, 11263 + 1),
-    "Glagolitic": range(11264, 11359 + 1),
-    "Latin Extended-C": range(11360, 11391 + 1),
-    "Coptic": range(11392, 11519 + 1),
-    "Georgian Supplement": range(11520, 11567 + 1),
-    "Tifinagh": range(11568, 11647 + 1),
-    "Ethiopic Extended": range(11648, 11743 + 1),
-    "Cyrillic Extended-A": range(11744, 11775 + 1),
-    "Supplemental Punctuation": range(11776, 11903 + 1),
-    "CJK Radicals Supplement": range(11904, 12031 + 1),
-    "Kangxi Radicals": range(12032, 12255 + 1),
-    "Ideographic Description Characters": range(12272, 12287 + 1),
-    "CJK Symbols and Punctuation": range(12288, 12351 + 1),
-    "Hiragana": range(12352, 12447 + 1),
-    "Katakana": range(12448, 12543 + 1),
-    "Bopomofo": range(12544, 12591 + 1),
-    "Hangul Compatibility Jamo": range(12592, 12687 + 1),
-    "Kanbun": range(12688, 12703 + 1),
-    "Bopomofo Extended": range(12704, 12735 + 1),
-    "CJK Strokes": range(12736, 12783 + 1),
-    "Katakana Phonetic Extensions": range(12784, 12799 + 1),
-    "Enclosed CJK Letters and Months": range(12800, 13055 + 1),
-    "CJK Compatibility": range(13056, 13311 + 1),
-    "CJK Unified Ideographs Extension A": range(13312, 19903 + 1),
-    "Yijing Hexagram Symbols": range(19904, 19967 + 1),
-    "CJK Unified Ideographs": range(19968, 40959 + 1),
-    "Yi Syllables": range(40960, 42127 + 1),
-    "Yi Radicals": range(42128, 42191 + 1),
-    "Lisu": range(42192, 42239 + 1),
-    "Vai": range(42240, 42559 + 1),
-    "Cyrillic Extended-B": range(42560, 42655 + 1),
-    "Bamum": range(42656, 42751 + 1),
-    "Modifier Tone Letters": range(42752, 42783 + 1),
-    "Latin Extended-D": range(42784, 43007 + 1),
-    "Syloti Nagri": range(43008, 43055 + 1),
-    "Common Indic Number Forms": range(43056, 43071 + 1),
-    "Phags-pa": range(43072, 43135 + 1),
-    "Saurashtra": range(43136, 43231 + 1),
-    "Devanagari Extended": range(43232, 43263 + 1),
-    "Kayah Li": range(43264, 43311 + 1),
-    "Rejang": range(43312, 43359 + 1),
-    "Hangul Jamo Extended-A": range(43360, 43391 + 1),
-    "Javanese": range(43392, 43487 + 1),
-    "Myanmar Extended-B": range(43488, 43519 + 1),
-    "Cham": range(43520, 43615 + 1),
-    "Myanmar Extended-A": range(43616, 43647 + 1),
-    "Tai Viet": range(43648, 43743 + 1),
-    "Meetei Mayek Extensions": range(43744, 43775 + 1),
-    "Ethiopic Extended-A": range(43776, 43823 + 1),
-    "Latin Extended-E": range(43824, 43887 + 1),
-    "Cherokee Supplement": range(43888, 43967 + 1),
-    "Meetei Mayek": range(43968, 44031 + 1),
-    "Hangul Syllables": range(44032, 55215 + 1),
-    "Hangul Jamo Extended-B": range(55216, 55295 + 1),
-    "High Surrogates": range(55296, 56191 + 1),
-    "High Private Use Surrogates": range(56192, 56319 + 1),
-    "Low Surrogates": range(56320, 57343 + 1),
-    "Private Use Area": range(57344, 63743 + 1),
-    "CJK Compatibility Ideographs": range(63744, 64255 + 1),
-    "Alphabetic Presentation Forms": range(64256, 64335 + 1),
-    "Arabic Presentation Forms-A": range(64336, 65023 + 1),
-    "Variation Selectors": range(65024, 65039 + 1),
-    "Vertical Forms": range(65040, 65055 + 1),
-    "Combining Half Marks": range(65056, 65071 + 1),
-    "CJK Compatibility Forms": range(65072, 65103 + 1),
-    "Small Form Variants": range(65104, 65135 + 1),
-    "Arabic Presentation Forms-B": range(65136, 65279 + 1),
-    "Halfwidth and Fullwidth Forms": range(65280, 65519 + 1),
-    "Specials": range(65520, 65535 + 1),
-    "Linear B Syllabary": range(65536, 65663 + 1),
-    "Linear B Ideograms": range(65664, 65791 + 1),
-    "Aegean Numbers": range(65792, 65855 + 1),
-    "Ancient Greek Numbers": range(65856, 65935 + 1),
-    "Ancient Symbols": range(65936, 65999 + 1),
-    "Phaistos Disc": range(66000, 66047 + 1),
-    "Lycian": range(66176, 66207 + 1),
-    "Carian": range(66208, 66271 + 1),
-    "Coptic Epact Numbers": range(66272, 66303 + 1),
-    "Old Italic": range(66304, 66351 + 1),
-    "Gothic": range(66352, 66383 + 1),
-    "Old Permic": range(66384, 66431 + 1),
-    "Ugaritic": range(66432, 66463 + 1),
-    "Old Persian": range(66464, 66527 + 1),
-    "Deseret": range(66560, 66639 + 1),
-    "Shavian": range(66640, 66687 + 1),
-    "Osmanya": range(66688, 66735 + 1),
-    "Osage": range(66736, 66815 + 1),
-    "Elbasan": range(66816, 66863 + 1),
-    "Caucasian Albanian": range(66864, 66927 + 1),
-    "Linear A": range(67072, 67455 + 1),
-    "Cypriot Syllabary": range(67584, 67647 + 1),
-    "Imperial Aramaic": range(67648, 67679 + 1),
-    "Palmyrene": range(67680, 67711 + 1),
-    "Nabataean": range(67712, 67759 + 1),
-    "Hatran": range(67808, 67839 + 1),
-    "Phoenician": range(67840, 67871 + 1),
-    "Lydian": range(67872, 67903 + 1),
-    "Meroitic Hieroglyphs": range(67968, 67999 + 1),
-    "Meroitic Cursive": range(68000, 68095 + 1),
-    "Kharoshthi": range(68096, 68191 + 1),
-    "Old South Arabian": range(68192, 68223 + 1),
-    "Old North Arabian": range(68224, 68255 + 1),
-    "Manichaean": range(68288, 68351 + 1),
-    "Avestan": range(68352, 68415 + 1),
-    "Inscriptional Parthian": range(68416, 68447 + 1),
-    "Inscriptional Pahlavi": range(68448, 68479 + 1),
-    "Psalter Pahlavi": range(68480, 68527 + 1),
-    "Old Turkic": range(68608, 68687 + 1),
-    "Old Hungarian": range(68736, 68863 + 1),
-    "Rumi Numeral Symbols": range(69216, 69247 + 1),
-    "Brahmi": range(69632, 69759 + 1),
-    "Kaithi": range(69760, 69839 + 1),
-    "Sora Sompeng": range(69840, 69887 + 1),
-    "Chakma": range(69888, 69967 + 1),
-    "Mahajani": range(69968, 70015 + 1),
-    "Sharada": range(70016, 70111 + 1),
-    "Sinhala Archaic Numbers": range(70112, 70143 + 1),
-    "Khojki": range(70144, 70223 + 1),
-    "Multani": range(70272, 70319 + 1),
-    "Khudawadi": range(70320, 70399 + 1),
-    "Grantha": range(70400, 70527 + 1),
-    "Newa": range(70656, 70783 + 1),
-    "Tirhuta": range(70784, 70879 + 1),
-    "Siddham": range(71040, 71167 + 1),
-    "Modi": range(71168, 71263 + 1),
-    "Mongolian Supplement": range(71264, 71295 + 1),
-    "Takri": range(71296, 71375 + 1),
-    "Ahom": range(71424, 71487 + 1),
-    "Warang Citi": range(71840, 71935 + 1),
-    "Zanabazar Square": range(72192, 72271 + 1),
-    "Soyombo": range(72272, 72367 + 1),
-    "Pau Cin Hau": range(72384, 72447 + 1),
-    "Bhaiksuki": range(72704, 72815 + 1),
-    "Marchen": range(72816, 72895 + 1),
-    "Masaram Gondi": range(72960, 73055 + 1),
-    "Cuneiform": range(73728, 74751 + 1),
-    "Cuneiform Numbers and Punctuation": range(74752, 74879 + 1),
-    "Early Dynastic Cuneiform": range(74880, 75087 + 1),
-    "Egyptian Hieroglyphs": range(77824, 78895 + 1),
-    "Anatolian Hieroglyphs": range(82944, 83583 + 1),
-    "Bamum Supplement": range(92160, 92735 + 1),
-    "Mro": range(92736, 92783 + 1),
-    "Bassa Vah": range(92880, 92927 + 1),
-    "Pahawh Hmong": range(92928, 93071 + 1),
-    "Miao": range(93952, 94111 + 1),
-    "Ideographic Symbols and Punctuation": range(94176, 94207 + 1),
-    "Tangut": range(94208, 100351 + 1),
-    "Tangut Components": range(100352, 101119 + 1),
-    "Kana Supplement": range(110592, 110847 + 1),
-    "Kana Extended-A": range(110848, 110895 + 1),
-    "Nushu": range(110960, 111359 + 1),
-    "Duployan": range(113664, 113823 + 1),
-    "Shorthand Format Controls": range(113824, 113839 + 1),
-    "Byzantine Musical Symbols": range(118784, 119039 + 1),
-    "Musical Symbols": range(119040, 119295 + 1),
-    "Ancient Greek Musical Notation": range(119296, 119375 + 1),
-    "Tai Xuan Jing Symbols": range(119552, 119647 + 1),
-    "Counting Rod Numerals": range(119648, 119679 + 1),
-    "Mathematical Alphanumeric Symbols": range(119808, 120831 + 1),
-    "Sutton SignWriting": range(120832, 121519 + 1),
-    "Glagolitic Supplement": range(122880, 122927 + 1),
-    "Mende Kikakui": range(124928, 125151 + 1),
-    "Adlam": range(125184, 125279 + 1),
-    "Arabic Mathematical Alphabetic Symbols": range(126464, 126719 + 1),
-    "Mahjong Tiles": range(126976, 127023 + 1),
-    "Domino Tiles": range(127024, 127135 + 1),
-    "Playing Cards": range(127136, 127231 + 1),
-    "Enclosed Alphanumeric Supplement": range(127232, 127487 + 1),
-    "Enclosed Ideographic Supplement": range(127488, 127743 + 1),
-    "Miscellaneous Symbols and Pictographs": range(127744, 128511 + 1),
-    "Emoticons range(Emoji)": range(128512, 128591 + 1),
-    "Ornamental Dingbats": range(128592, 128639 + 1),
-    "Transport and Map Symbols": range(128640, 128767 + 1),
-    "Alchemical Symbols": range(128768, 128895 + 1),
-    "Geometric Shapes Extended": range(128896, 129023 + 1),
-    "Supplemental Arrows-C": range(129024, 129279 + 1),
-    "Supplemental Symbols and Pictographs": range(129280, 129535 + 1),
-    "CJK Unified Ideographs Extension B": range(131072, 173791 + 1),
-    "CJK Unified Ideographs Extension C": range(173824, 177983 + 1),
-    "CJK Unified Ideographs Extension D": range(177984, 178207 + 1),
-    "CJK Unified Ideographs Extension E": range(178208, 183983 + 1),
-    "CJK Unified Ideographs Extension F": range(183984, 191471 + 1),
-    "CJK Compatibility Ideographs Supplement": range(194560, 195103 + 1),
-    "Tags": range(917504, 917631 + 1),
-    "Variation Selectors Supplement": range(917760, 917999 + 1),
-}  # type: Dict[str, range]
-
-UNICODE_SECONDARY_RANGE_KEYWORD = [
-    "Supplement",
-    "Extended",
-    "Extensions",
-    "Modifier",
-    "Marks",
-    "Punctuation",
-    "Symbols",
-    "Forms",
-    "Operators",
-    "Miscellaneous",
-    "Drawing",
-    "Block",
-    "Shapes",
-    "Supplemental",
-    "Tags",
-]  # type: List[str]
-
-RE_POSSIBLE_ENCODING_INDICATION = re_compile(
-    r"(?:(?:encoding)|(?:charset)|(?:coding))(?:[\:= ]{1,10})(?:[\"\']?)([a-zA-Z0-9\-_]+)(?:[\"\']?)",
-    IGNORECASE,
-)
-
-IANA_SUPPORTED = sorted(
-    filter(
-        lambda x: x.endswith("_codec") is False
-        and x not in {"rot_13", "tactis", "mbcs"},
-        list(set(aliases.values())),
-    )
-)  # type: List[str]
-
-IANA_SUPPORTED_COUNT = len(IANA_SUPPORTED)  # type: int
-
-# pre-computed code page that are similar using the function cp_similarity.
-IANA_SUPPORTED_SIMILAR = {
-    "cp037": ["cp1026", "cp1140", "cp273", "cp500"],
-    "cp1026": ["cp037", "cp1140", "cp273", "cp500"],
-    "cp1125": ["cp866"],
-    "cp1140": ["cp037", "cp1026", "cp273", "cp500"],
-    "cp1250": ["iso8859_2"],
-    "cp1251": ["kz1048", "ptcp154"],
-    "cp1252": ["cp1258", "iso8859_15", "iso8859_9", "latin_1"],
-    "cp1253": ["iso8859_7"],
-    "cp1254": ["cp1258", "iso8859_15", "iso8859_9", "latin_1"],
-    "cp1257": ["iso8859_13"],
-    "cp1258": ["cp1252", "cp1254", "iso8859_9", "latin_1"],
-    "cp273": ["cp037", "cp1026", "cp1140", "cp500"],
-    "cp437": ["cp850", "cp858", "cp860", "cp861", "cp862", "cp863", "cp865"],
-    "cp500": ["cp037", "cp1026", "cp1140", "cp273"],
-    "cp850": ["cp437", "cp857", "cp858", "cp865"],
-    "cp857": ["cp850", "cp858", "cp865"],
-    "cp858": ["cp437", "cp850", "cp857", "cp865"],
-    "cp860": ["cp437", "cp861", "cp862", "cp863", "cp865"],
-    "cp861": ["cp437", "cp860", "cp862", "cp863", "cp865"],
-    "cp862": ["cp437", "cp860", "cp861", "cp863", "cp865"],
-    "cp863": ["cp437", "cp860", "cp861", "cp862", "cp865"],
-    "cp865": ["cp437", "cp850", "cp857", "cp858", "cp860", "cp861", "cp862", "cp863"],
-    "cp866": ["cp1125"],
-    "iso8859_10": ["iso8859_14", "iso8859_15", "iso8859_4", "iso8859_9", "latin_1"],
-    "iso8859_11": ["tis_620"],
-    "iso8859_13": ["cp1257"],
-    "iso8859_14": [
-        "iso8859_10",
-        "iso8859_15",
-        "iso8859_16",
-        "iso8859_3",
-        "iso8859_9",
-        "latin_1",
-    ],
-    "iso8859_15": [
-        "cp1252",
-        "cp1254",
-        "iso8859_10",
-        "iso8859_14",
-        "iso8859_16",
-        "iso8859_3",
-        "iso8859_9",
-        "latin_1",
-    ],
-    "iso8859_16": [
-        "iso8859_14",
-        "iso8859_15",
-        "iso8859_2",
-        "iso8859_3",
-        "iso8859_9",
-        "latin_1",
-    ],
-    "iso8859_2": ["cp1250", "iso8859_16", "iso8859_4"],
-    "iso8859_3": ["iso8859_14", "iso8859_15", "iso8859_16", "iso8859_9", "latin_1"],
-    "iso8859_4": ["iso8859_10", "iso8859_2", "iso8859_9", "latin_1"],
-    "iso8859_7": ["cp1253"],
-    "iso8859_9": [
-        "cp1252",
-        "cp1254",
-        "cp1258",
-        "iso8859_10",
-        "iso8859_14",
-        "iso8859_15",
-        "iso8859_16",
-        "iso8859_3",
-        "iso8859_4",
-        "latin_1",
-    ],
-    "kz1048": ["cp1251", "ptcp154"],
-    "latin_1": [
-        "cp1252",
-        "cp1254",
-        "cp1258",
-        "iso8859_10",
-        "iso8859_14",
-        "iso8859_15",
-        "iso8859_16",
-        "iso8859_3",
-        "iso8859_4",
-        "iso8859_9",
-    ],
-    "mac_iceland": ["mac_roman", "mac_turkish"],
-    "mac_roman": ["mac_iceland", "mac_turkish"],
-    "mac_turkish": ["mac_iceland", "mac_roman"],
-    "ptcp154": ["cp1251", "kz1048"],
-    "tis_620": ["iso8859_11"],
-}  # type: Dict[str, List[str]]
-
-
-CHARDET_CORRESPONDENCE = {
-    "iso2022_kr": "ISO-2022-KR",
-    "iso2022_jp": "ISO-2022-JP",
-    "euc_kr": "EUC-KR",
-    "tis_620": "TIS-620",
-    "utf_32": "UTF-32",
-    "euc_jp": "EUC-JP",
-    "koi8_r": "KOI8-R",
-    "iso8859_1": "ISO-8859-1",
-    "iso8859_2": "ISO-8859-2",
-    "iso8859_5": "ISO-8859-5",
-    "iso8859_6": "ISO-8859-6",
-    "iso8859_7": "ISO-8859-7",
-    "iso8859_8": "ISO-8859-8",
-    "utf_16": "UTF-16",
-    "cp855": "IBM855",
-    "mac_cyrillic": "MacCyrillic",
-    "gb2312": "GB2312",
-    "gb18030": "GB18030",
-    "cp932": "CP932",
-    "cp866": "IBM866",
-    "utf_8": "utf-8",
-    "utf_8_sig": "UTF-8-SIG",
-    "shift_jis": "SHIFT_JIS",
-    "big5": "Big5",
-    "cp1250": "windows-1250",
-    "cp1251": "windows-1251",
-    "cp1252": "Windows-1252",
-    "cp1253": "windows-1253",
-    "cp1255": "windows-1255",
-    "cp1256": "windows-1256",
-    "cp1254": "Windows-1254",
-    "cp949": "CP949",
-}  # type: Dict[str, str]
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/legacy.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/legacy.py
deleted file mode 100644
index 48feacb..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/legacy.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from charset_normalizer.api import from_bytes
-from charset_normalizer.constant import CHARDET_CORRESPONDENCE
-from typing import Dict, Optional, Union
-
-
-def detect(byte_str: bytes) -> Dict[str, Optional[Union[str, float]]]:
-    """
-    chardet legacy method
-    Detect the encoding of the given byte string. It should be mostly backward-compatible.
-    Encoding name will match Chardet own writing whenever possible. (Not on encoding name unsupported by it)
-    This function is deprecated and should be used to migrate your project easily, consult the documentation for
-    further information. Not planned for removal.
-
-    :param byte_str:     The byte sequence to examine.
-    """
-    if not isinstance(byte_str, (bytearray, bytes)):
-        raise TypeError(
-            "Expected object of type bytes or bytearray, got: "
-            "{0}".format(type(byte_str))
-        )
-
-    if isinstance(byte_str, bytearray):
-        byte_str = bytes(byte_str)
-
-    r = from_bytes(byte_str).best()
-
-    encoding = r.encoding if r is not None else None
-    language = r.language if r is not None and r.language != "Unknown" else ""
-    confidence = 1.0 - r.chaos if r is not None else None
-
-    # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process
-    # but chardet does return 'utf-8-sig' and it is a valid codec name.
-    if r is not None and encoding == "utf_8" and r.bom:
-        encoding += "_sig"
-
-    return {
-        "encoding": encoding
-        if encoding not in CHARDET_CORRESPONDENCE
-        else CHARDET_CORRESPONDENCE[encoding],
-        "language": language,
-        "confidence": confidence,
-    }
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/md.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/md.py
deleted file mode 100644
index 7fa58d6..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/md.py
+++ /dev/null
@@ -1,541 +0,0 @@
-from functools import lru_cache
-from typing import Optional, List
-
-from charset_normalizer.constant import UNICODE_SECONDARY_RANGE_KEYWORD
-from charset_normalizer.utils import (
-    is_punctuation,
-    is_symbol,
-    unicode_range,
-    is_accentuated,
-    is_latin,
-    remove_accent,
-    is_separator,
-    is_cjk,
-    is_case_variable,
-    is_hangul,
-    is_katakana,
-    is_hiragana,
-    is_ascii,
-    is_thai,
-)
-
-
-class MessDetectorPlugin:
-    """
-    Base abstract class used for mess detection plugins.
-    All detectors MUST extend and implement given methods.
-    """
-
-    def eligible(self, character: str) -> bool:
-        """
-        Determine if given character should be fed in.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    def feed(self, character: str) -> None:
-        """
-        The main routine to be executed upon character.
-        Insert the logic in witch the text would be considered chaotic.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    def reset(self) -> None:
-        """
-        Permit to reset the plugin to the initial state.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-    @property
-    def ratio(self) -> float:
-        """
-        Compute the chaos ratio based on what your feed() has seen.
-        Must NOT be lower than 0.; No restriction gt 0.
-        """
-        raise NotImplementedError  # pragma: nocover
-
-
-class TooManySymbolOrPunctuationPlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._punctuation_count = 0  # type: int
-        self._symbol_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-        self._last_printable_char = None  # type: Optional[str]
-        self._frenzy_symbol_in_word = False  # type: bool
-
-    def eligible(self, character: str) -> bool:
-        return character.isprintable()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if character != self._last_printable_char and character not in [
-            "<",
-            ">",
-            "=",
-            ":",
-            "/",
-            "&",
-            ";",
-            "{",
-            "}",
-            "[",
-            "]",
-            ",",
-            "|",
-            '"',
-        ]:
-            if is_punctuation(character):
-                self._punctuation_count += 1
-            elif character.isdigit() is False and is_symbol(character):
-                self._symbol_count += 2
-
-        self._last_printable_char = character
-
-    def reset(self) -> None:
-        self._punctuation_count = 0
-        self._character_count = 0
-        self._symbol_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-
-        ratio_of_punctuation = (
-            self._punctuation_count + self._symbol_count
-        ) / self._character_count  # type: float
-
-        return ratio_of_punctuation if ratio_of_punctuation >= 0.3 else 0.0
-
-
-class TooManyAccentuatedPlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._character_count = 0  # type: int
-        self._accentuated_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return character.isalpha()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if is_accentuated(character):
-            self._accentuated_count += 1
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._accentuated_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-        ratio_of_accentuation = (
-            self._accentuated_count / self._character_count
-        )  # type: float
-        return ratio_of_accentuation if ratio_of_accentuation >= 0.35 else 0.0
-
-
-class UnprintablePlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._unprintable_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if (
-            character not in {"\n", "\t", "\r", "\v"}
-            and character.isprintable() is False
-        ):
-            self._unprintable_count += 1
-        self._character_count += 1
-
-    def reset(self) -> None:
-        self._unprintable_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-
-        return (self._unprintable_count * 8) / self._character_count
-
-
-class SuspiciousDuplicateAccentPlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._successive_count = 0  # type: int
-        self._character_count = 0  # type: int
-
-        self._last_latin_character = None  # type: Optional[str]
-
-    def eligible(self, character: str) -> bool:
-        return character.isalpha() and is_latin(character)
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-        if self._last_latin_character is not None:
-            if is_accentuated(character) and is_accentuated(self._last_latin_character):
-                if character.isupper() and self._last_latin_character.isupper():
-                    self._successive_count += 1
-                # Worse if its the same char duplicated with different accent.
-                if remove_accent(character) == remove_accent(
-                    self._last_latin_character
-                ):
-                    self._successive_count += 1
-        self._last_latin_character = character
-
-    def reset(self) -> None:
-        self._successive_count = 0
-        self._character_count = 0
-        self._last_latin_character = None
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-
-        return (self._successive_count * 2) / self._character_count
-
-
-class SuspiciousRange(MessDetectorPlugin):
-    def __init__(self):
-        self._suspicious_successive_range_count = 0  # type: int
-        self._character_count = 0  # type: int
-        self._last_printable_seen = None  # type: Optional[str]
-
-    def eligible(self, character: str) -> bool:
-        return character.isprintable()
-
-    def feed(self, character: str) -> None:
-        self._character_count += 1
-
-        if character.isspace() or is_punctuation(character):
-            self._last_printable_seen = None
-            return
-
-        if self._last_printable_seen is None:
-            self._last_printable_seen = character
-            return
-
-        unicode_range_a = unicode_range(
-            self._last_printable_seen
-        )  # type: Optional[str]
-        unicode_range_b = unicode_range(character)  # type: Optional[str]
-
-        if is_suspiciously_successive_range(unicode_range_a, unicode_range_b):
-            self._suspicious_successive_range_count += 1
-
-        self._last_printable_seen = character
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._suspicious_successive_range_count = 0
-        self._last_printable_seen = None
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-
-        ratio_of_suspicious_range_usage = (
-            self._suspicious_successive_range_count * 2
-        ) / self._character_count  # type: float
-
-        if ratio_of_suspicious_range_usage < 0.1:
-            return 0.0
-
-        return ratio_of_suspicious_range_usage
-
-
-class SuperWeirdWordPlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._word_count = 0  # type: int
-        self._bad_word_count = 0  # type: int
-        self._is_current_word_bad = False  # type: bool
-        self._foreign_long_watch = False  # type: bool
-
-        self._character_count = 0  # type: int
-        self._bad_character_count = 0  # type: int
-
-        self._buffer = ""  # type: str
-        self._buffer_accent_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if character.isalpha():
-            self._buffer = "".join([self._buffer, character])
-            if is_accentuated(character):
-                self._buffer_accent_count += 1
-            if (
-                self._foreign_long_watch is False
-                and is_latin(character) is False
-                and is_cjk(character) is False
-                and is_hangul(character) is False
-                and is_katakana(character) is False
-                and is_hiragana(character) is False
-                and is_thai(character) is False
-            ):
-                self._foreign_long_watch = True
-            return
-        if not self._buffer:
-            return
-        if (
-            character.isspace() or is_punctuation(character) or is_separator(character)
-        ) and self._buffer:
-            self._word_count += 1
-            buffer_length = len(self._buffer)  # type: int
-
-            self._character_count += buffer_length
-
-            if buffer_length >= 4 and self._buffer_accent_count / buffer_length >= 0.3:
-                self._is_current_word_bad = True
-            if buffer_length >= 24 and self._foreign_long_watch:
-                self._is_current_word_bad = True
-
-            if self._is_current_word_bad:
-                self._bad_word_count += 1
-                self._bad_character_count += len(self._buffer)
-                self._is_current_word_bad = False
-
-            self._foreign_long_watch = False
-            self._buffer = ""
-            self._buffer_accent_count = 0
-        elif (
-            character not in {"<", ">", "-", "="}
-            and character.isdigit() is False
-            and is_symbol(character)
-        ):
-            self._is_current_word_bad = True
-            self._buffer += character
-
-    def reset(self) -> None:
-        self._buffer = ""
-        self._is_current_word_bad = False
-        self._foreign_long_watch = False
-        self._bad_word_count = 0
-        self._word_count = 0
-        self._character_count = 0
-        self._bad_character_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._word_count <= 10:
-            return 0.0
-
-        return self._bad_character_count / self._character_count
-
-
-class CjkInvalidStopPlugin(MessDetectorPlugin):
-    """
-    GB(Chinese) based encoding often render the stop incorrectly when the content does not fit and can be easily detected.
-    Searching for the overuse of '丅' and '丄'.
-    """
-
-    def __init__(self):
-        self._wrong_stop_count = 0  # type: int
-        self._cjk_character_count = 0  # type: int
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        if character in ["丅", "丄"]:
-            self._wrong_stop_count += 1
-            return
-        if is_cjk(character):
-            self._cjk_character_count += 1
-
-    def reset(self) -> None:
-        self._wrong_stop_count = 0
-        self._cjk_character_count = 0
-
-    @property
-    def ratio(self) -> float:
-        if self._cjk_character_count < 16:
-            return 0.0
-        return self._wrong_stop_count / self._cjk_character_count
-
-
-class ArchaicUpperLowerPlugin(MessDetectorPlugin):
-    def __init__(self):
-        self._buf = False  # type: bool
-
-        self._character_count_since_last_sep = 0  # type: int
-
-        self._successive_upper_lower_count = 0  # type: int
-        self._successive_upper_lower_count_final = 0  # type: int
-
-        self._character_count = 0  # type: int
-
-        self._last_alpha_seen = None  # type: Optional[str]
-        self._current_ascii_only = True  # type: bool
-
-    def eligible(self, character: str) -> bool:
-        return True
-
-    def feed(self, character: str) -> None:
-        is_concerned = character.isalpha() and is_case_variable(character)
-        chunk_sep = is_concerned is False
-
-        if chunk_sep and self._character_count_since_last_sep > 0:
-            if (
-                self._character_count_since_last_sep <= 64
-                and character.isdigit() is False
-                and self._current_ascii_only is False
-            ):
-                self._successive_upper_lower_count_final += (
-                    self._successive_upper_lower_count
-                )
-
-            self._successive_upper_lower_count = 0
-            self._character_count_since_last_sep = 0
-            self._last_alpha_seen = None
-            self._buf = False
-            self._character_count += 1
-            self._current_ascii_only = True
-
-            return
-
-        if self._current_ascii_only is True and is_ascii(character) is False:
-            self._current_ascii_only = False
-
-        if self._last_alpha_seen is not None:
-            if (character.isupper() and self._last_alpha_seen.islower()) or (
-                character.islower() and self._last_alpha_seen.isupper()
-            ):
-                if self._buf is True:
-                    self._successive_upper_lower_count += 2
-                    self._buf = False
-                else:
-                    self._buf = True
-            else:
-                self._buf = False
-
-        self._character_count += 1
-        self._character_count_since_last_sep += 1
-        self._last_alpha_seen = character
-
-    def reset(self) -> None:
-        self._character_count = 0
-        self._character_count_since_last_sep = 0
-        self._successive_upper_lower_count = 0
-        self._successive_upper_lower_count_final = 0
-        self._last_alpha_seen = None
-        self._buf = False
-        self._current_ascii_only = True
-
-    @property
-    def ratio(self) -> float:
-        if self._character_count == 0:
-            return 0.0
-
-        return self._successive_upper_lower_count_final / self._character_count
-
-
-def is_suspiciously_successive_range(
-    unicode_range_a: Optional[str], unicode_range_b: Optional[str]
-) -> bool:
-    """
-    Determine if two Unicode range seen next to each other can be considered as suspicious.
-    """
-    if unicode_range_a is None or unicode_range_b is None:
-        return True
-
-    if unicode_range_a == unicode_range_b:
-        return False
-
-    if "Latin" in unicode_range_a and "Latin" in unicode_range_b:
-        return False
-
-    if "Emoticons" in unicode_range_a or "Emoticons" in unicode_range_b:
-        return False
-
-    keywords_range_a, keywords_range_b = unicode_range_a.split(
-        " "
-    ), unicode_range_b.split(" ")
-
-    for el in keywords_range_a:
-        if el in UNICODE_SECONDARY_RANGE_KEYWORD:
-            continue
-        if el in keywords_range_b:
-            return False
-
-    # Japanese Exception
-    if unicode_range_a in ["Katakana", "Hiragana"] and unicode_range_b in [
-        "Katakana",
-        "Hiragana",
-    ]:
-        return False
-
-    if unicode_range_a in ["Katakana", "Hiragana"] or unicode_range_b in [
-        "Katakana",
-        "Hiragana",
-    ]:
-        if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
-            return False
-
-    if "Hangul" in unicode_range_a or "Hangul" in unicode_range_b:
-        if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
-            return False
-        if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
-            return False
-
-    # Chinese/Japanese use dedicated range for punctuation and/or separators.
-    if ("CJK" in unicode_range_a or "CJK" in unicode_range_b) or (
-        unicode_range_a in ["Katakana", "Hiragana"]
-        and unicode_range_b in ["Katakana", "Hiragana"]
-    ):
-        if "Punctuation" in unicode_range_a or "Punctuation" in unicode_range_b:
-            return False
-        if "Forms" in unicode_range_a or "Forms" in unicode_range_b:
-            return False
-
-    return True
-
-
-@lru_cache(maxsize=2048)
-def mess_ratio(
-    decoded_sequence: str, maximum_threshold: float = 0.2, debug: bool = False
-) -> float:
-    """
-    Compute a mess ratio given a decoded bytes sequence. The maximum threshold does stop the computation earlier.
-    """
-    detectors = []  # type: List[MessDetectorPlugin]
-
-    for md_class in MessDetectorPlugin.__subclasses__():
-        detectors.append(md_class())
-
-    length = len(decoded_sequence)  # type: int
-
-    mean_mess_ratio = 0.0  # type: float
-
-    if length < 512:
-        intermediary_mean_mess_ratio_calc = 32  # type: int
-    elif length <= 1024:
-        intermediary_mean_mess_ratio_calc = 64
-    else:
-        intermediary_mean_mess_ratio_calc = 128
-
-    for character, index in zip(decoded_sequence, range(0, length)):
-        for detector in detectors:
-            if detector.eligible(character):
-                detector.feed(character)
-
-        if (
-            index > 0 and index % intermediary_mean_mess_ratio_calc == 0
-        ) or index == length - 1:
-            mean_mess_ratio = sum([dt.ratio for dt in detectors])
-
-            if mean_mess_ratio >= maximum_threshold:
-                break
-
-    if debug:
-        for dt in detectors:  # pragma: nocover
-            print(dt.__class__, dt.ratio)
-
-    return round(mean_mess_ratio, 3)
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/models.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/models.py
deleted file mode 100644
index f629c7d..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/models.py
+++ /dev/null
@@ -1,385 +0,0 @@
-import warnings
-from encodings.aliases import aliases
-from hashlib import sha256
-from json import dumps
-from typing import Optional, List, Tuple, Set
-from collections import Counter
-from re import sub, compile as re_compile
-
-from charset_normalizer.constant import TOO_BIG_SEQUENCE
-from charset_normalizer.md import mess_ratio
-from charset_normalizer.utils import iana_name, is_multi_byte_encoding, unicode_range
-
-
-class CharsetMatch:
-    def __init__(
-        self,
-        payload: bytes,
-        guessed_encoding: str,
-        mean_mess_ratio: float,
-        has_sig_or_bom: bool,
-        languages: "CoherenceMatches",
-        decoded_payload: Optional[str] = None,
-    ):
-        self._payload = payload  # type: bytes
-
-        self._encoding = guessed_encoding  # type: str
-        self._mean_mess_ratio = mean_mess_ratio  # type: float
-        self._languages = languages  # type: CoherenceMatches
-        self._has_sig_or_bom = has_sig_or_bom  # type: bool
-        self._unicode_ranges = None  # type: Optional[List[str]]
-
-        self._leaves = []  # type: List[CharsetMatch]
-        self._mean_coherence_ratio = 0.0  # type: float
-
-        self._output_payload = None  # type: Optional[bytes]
-        self._output_encoding = None  # type: Optional[str]
-
-        self._string = decoded_payload  # type: Optional[str]
-
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, CharsetMatch):
-            raise TypeError(
-                "__eq__ cannot be invoked on {} and {}.".format(
-                    str(other.__class__), str(self.__class__)
-                )
-            )
-        return self.encoding == other.encoding and self.fingerprint == other.fingerprint
-
-    def __lt__(self, other) -> bool:
-        """
-        Implemented to make sorted available upon CharsetMatches items.
-        """
-        if not isinstance(other, CharsetMatch):
-            raise ValueError
-
-        chaos_difference = abs(self.chaos - other.chaos)  # type: float
-
-        # Bellow 1% difference --> Use Coherence
-        if chaos_difference < 0.01:
-            return self.coherence > other.coherence
-
-        return self.chaos < other.chaos
-
-    @property
-    def chaos_secondary_pass(self) -> float:
-        """
-        Check once again chaos in decoded text, except this time, with full content.
-        Use with caution, this can be very slow.
-        Notice: Will be removed in 3.0
-        """
-        warnings.warn(
-            "chaos_secondary_pass is deprecated and will be removed in 3.0",
-            DeprecationWarning,
-        )
-        return mess_ratio(str(self), 1.0)
-
-    @property
-    def coherence_non_latin(self) -> float:
-        """
-        Coherence ratio on the first non-latin language detected if ANY.
-        Notice: Will be removed in 3.0
-        """
-        warnings.warn(
-            "coherence_non_latin is deprecated and will be removed in 3.0",
-            DeprecationWarning,
-        )
-        return 0.0
-
-    @property
-    def w_counter(self) -> Counter:
-        """
-        Word counter instance on decoded text.
-        Notice: Will be removed in 3.0
-        """
-        warnings.warn(
-            "w_counter is deprecated and will be removed in 3.0", DeprecationWarning
-        )
-        not_printable_pattern = re_compile(r"[0-9\W\n\r\t]+")
-        string_printable_only = sub(not_printable_pattern, " ", str(self).lower())
-
-        return Counter(string_printable_only.split())
-
-    def __str__(self) -> str:
-        # Lazy Str Loading
-        if self._string is None:
-            self._string = str(self._payload, self._encoding, "strict")
-        return self._string
-
-    def __repr__(self) -> str:
-        return "<CharsetMatch '{}' bytes({})>".format(self.encoding, self.fingerprint)
-
-    def add_submatch(self, other: "CharsetMatch") -> None:
-        if not isinstance(other, CharsetMatch) or other == self:
-            raise ValueError(
-                "Unable to add instance <{}> as a submatch of a CharsetMatch".format(
-                    other.__class__
-                )
-            )
-
-        other._string = None  # Unload RAM usage; dirty trick.
-        self._leaves.append(other)
-
-    @property
-    def encoding(self) -> str:
-        return self._encoding
-
-    @property
-    def encoding_aliases(self) -> List[str]:
-        """
-        Encoding name are known by many name, using this could help when searching for IBM855 when it's listed as CP855.
-        """
-        also_known_as = []  # type: List[str]
-        for u, p in aliases.items():
-            if self.encoding == u:
-                also_known_as.append(p)
-            elif self.encoding == p:
-                also_known_as.append(u)
-        return also_known_as
-
-    @property
-    def bom(self) -> bool:
-        return self._has_sig_or_bom
-
-    @property
-    def byte_order_mark(self) -> bool:
-        return self._has_sig_or_bom
-
-    @property
-    def languages(self) -> List[str]:
-        """
-        Return the complete list of possible languages found in decoded sequence.
-        Usually not really useful. Returned list may be empty even if 'language' property return something != 'Unknown'.
-        """
-        return [e[0] for e in self._languages]
-
-    @property
-    def language(self) -> str:
-        """
-        Most probable language found in decoded sequence. If none were detected or inferred, the property will return
-        "Unknown".
-        """
-        if not self._languages:
-            # Trying to infer the language based on the given encoding
-            # Its either English or we should not pronounce ourselves in certain cases.
-            if "ascii" in self.could_be_from_charset:
-                return "English"
-
-            # doing it there to avoid circular import
-            from charset_normalizer.cd import mb_encoding_languages, encoding_languages
-
-            languages = (
-                mb_encoding_languages(self.encoding)
-                if is_multi_byte_encoding(self.encoding)
-                else encoding_languages(self.encoding)
-            )
-
-            if len(languages) == 0 or "Latin Based" in languages:
-                return "Unknown"
-
-            return languages[0]
-
-        return self._languages[0][0]
-
-    @property
-    def chaos(self) -> float:
-        return self._mean_mess_ratio
-
-    @property
-    def coherence(self) -> float:
-        if not self._languages:
-            return 0.0
-        return self._languages[0][1]
-
-    @property
-    def percent_chaos(self) -> float:
-        return round(self.chaos * 100, ndigits=3)
-
-    @property
-    def percent_coherence(self) -> float:
-        return round(self.coherence * 100, ndigits=3)
-
-    @property
-    def raw(self) -> bytes:
-        """
-        Original untouched bytes.
-        """
-        return self._payload
-
-    @property
-    def submatch(self) -> List["CharsetMatch"]:
-        return self._leaves
-
-    @property
-    def has_submatch(self) -> bool:
-        return len(self._leaves) > 0
-
-    @property
-    def alphabets(self) -> List[str]:
-        if self._unicode_ranges is not None:
-            return self._unicode_ranges
-        detected_ranges = set()  # type: Set[str]
-        for character in str(self):
-            detected_range = unicode_range(character)  # type: Optional[str]
-            if detected_range:
-                detected_ranges.add(unicode_range(character))
-        self._unicode_ranges = sorted(list(detected_ranges))
-        return self._unicode_ranges
-
-    @property
-    def could_be_from_charset(self) -> List[str]:
-        """
-        The complete list of encoding that output the exact SAME str result and therefore could be the originating
-        encoding.
-        This list does include the encoding available in property 'encoding'.
-        """
-        return [self._encoding] + [m.encoding for m in self._leaves]
-
-    def first(self) -> "CharsetMatch":
-        """
-        Kept for BC reasons. Will be removed in 3.0.
-        """
-        return self
-
-    def best(self) -> "CharsetMatch":
-        """
-        Kept for BC reasons. Will be removed in 3.0.
-        """
-        return self
-
-    def output(self, encoding: str = "utf_8") -> bytes:
-        """
-        Method to get re-encoded bytes payload using given target encoding. Default to UTF-8.
-        Any errors will be simply ignored by the encoder NOT replaced.
-        """
-        if self._output_encoding is None or self._output_encoding != encoding:
-            self._output_encoding = encoding
-            self._output_payload = str(self).encode(encoding, "replace")
-
-        return self._output_payload  # type: ignore
-
-    @property
-    def fingerprint(self) -> str:
-        """
-        Retrieve the unique SHA256 computed using the transformed (re-encoded) payload. Not the original one.
-        """
-        return sha256(self.output()).hexdigest()
-
-
-class CharsetMatches:
-    """
-    Container with every CharsetMatch items ordered by default from most probable to the less one.
-    Act like a list(iterable) but does not implements all related methods.
-    """
-
-    def __init__(self, results: List[CharsetMatch] = None):
-        self._results = sorted(results) if results else []  # type: List[CharsetMatch]
-
-    def __iter__(self):
-        for result in self._results:
-            yield result
-
-    def __getitem__(self, item) -> CharsetMatch:
-        """
-        Retrieve a single item either by its position or encoding name (alias may be used here).
-        Raise KeyError upon invalid index or encoding not present in results.
-        """
-        if isinstance(item, int):
-            return self._results[item]
-        if isinstance(item, str):
-            item = iana_name(item, False)
-            for result in self._results:
-                if item in result.could_be_from_charset:
-                    return result
-        raise KeyError
-
-    def __len__(self) -> int:
-        return len(self._results)
-
-    def append(self, item: CharsetMatch) -> None:
-        """
-        Insert a single match. Will be inserted accordingly to preserve sort.
-        Can be inserted as a submatch.
-        """
-        if not isinstance(item, CharsetMatch):
-            raise ValueError(
-                "Cannot append instance '{}' to CharsetMatches".format(
-                    str(item.__class__)
-                )
-            )
-        # We should disable the submatch factoring when the input file is too heavy (conserve RAM usage)
-        if len(item.raw) <= TOO_BIG_SEQUENCE:
-            for match in self._results:
-                if match.fingerprint == item.fingerprint and match.chaos == item.chaos:
-                    match.add_submatch(item)
-                    return
-        self._results.append(item)
-        self._results = sorted(self._results)
-
-    def best(self) -> Optional["CharsetMatch"]:
-        """
-        Simply return the first match. Strict equivalent to matches[0].
-        """
-        if not self._results:
-            return None
-        return self._results[0]
-
-    def first(self) -> Optional["CharsetMatch"]:
-        """
-        Redundant method, call the method best(). Kept for BC reasons.
-        """
-        return self.best()
-
-
-CoherenceMatch = Tuple[str, float]
-CoherenceMatches = List[CoherenceMatch]
-
-
-class CliDetectionResult:
-    def __init__(
-        self,
-        path: str,
-        encoding: str,
-        encoding_aliases: List[str],
-        alternative_encodings: List[str],
-        language: str,
-        alphabets: List[str],
-        has_sig_or_bom: bool,
-        chaos: float,
-        coherence: float,
-        unicode_path: Optional[str],
-        is_preferred: bool,
-    ):
-        self.path = path  # type: str
-        self.unicode_path = unicode_path  # type: Optional[str]
-        self.encoding = encoding  # type: str
-        self.encoding_aliases = encoding_aliases  # type: List[str]
-        self.alternative_encodings = alternative_encodings  # type: List[str]
-        self.language = language  # type: str
-        self.alphabets = alphabets  # type: List[str]
-        self.has_sig_or_bom = has_sig_or_bom  # type: bool
-        self.chaos = chaos  # type: float
-        self.coherence = coherence  # type: float
-        self.is_preferred = is_preferred  # type: bool
-
-    @property
-    def __dict__(self):
-        return {
-            "path": self.path,
-            "encoding": self.encoding,
-            "encoding_aliases": self.encoding_aliases,
-            "alternative_encodings": self.alternative_encodings,
-            "language": self.language,
-            "alphabets": self.alphabets,
-            "has_sig_or_bom": self.has_sig_or_bom,
-            "chaos": self.chaos,
-            "coherence": self.coherence,
-            "unicode_path": self.unicode_path,
-            "is_preferred": self.is_preferred,
-        }
-
-    def to_json(self) -> str:
-        return dumps(self.__dict__, ensure_ascii=True, indent=4)
-
-
-CharsetNormalizerMatch = CharsetMatch
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/py.typed b/addon/globalPlugins/spellcheck/libs/charset_normalizer/py.typed
deleted file mode 100644
index e69de29..0000000
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/utils.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/utils.py
deleted file mode 100644
index c2cf2e6..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/utils.py
+++ /dev/null
@@ -1,322 +0,0 @@
-try:
-    import unicodedata2 as unicodedata
-except ImportError:
-    import unicodedata
-
-from codecs import IncrementalDecoder
-from re import findall
-from typing import Optional, Tuple, Union, List, Set
-import importlib
-from _multibytecodec import MultibyteIncrementalDecoder  # type: ignore
-
-from encodings.aliases import aliases
-from functools import lru_cache
-
-from charset_normalizer.constant import (
-    UNICODE_RANGES_COMBINED,
-    UNICODE_SECONDARY_RANGE_KEYWORD,
-    RE_POSSIBLE_ENCODING_INDICATION,
-    ENCODING_MARKS,
-    UTF8_MAXIMAL_ALLOCATION,
-    IANA_SUPPORTED_SIMILAR,
-)
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_accentuated(character: str) -> bool:
-    try:
-        description = unicodedata.name(character)  # type: str
-    except ValueError:
-        return False
-    return (
-        "WITH GRAVE" in description
-        or "WITH ACUTE" in description
-        or "WITH CEDILLA" in description
-        or "WITH DIAERESIS" in description
-        or "WITH CIRCUMFLEX" in description
-    )
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def remove_accent(character: str) -> str:
-    decomposed = unicodedata.decomposition(character)  # type: str
-    if not decomposed:
-        return character
-
-    codes = decomposed.split(" ")  # type: List[str]
-
-    return chr(int(codes[0], 16))
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def unicode_range(character: str) -> Optional[str]:
-    """
-    Retrieve the Unicode range official name from a single character.
-    """
-    character_ord = ord(character)  # type: int
-
-    for range_name, ord_range in UNICODE_RANGES_COMBINED.items():
-        if character_ord in ord_range:
-            return range_name
-
-    return None
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_latin(character: str) -> bool:
-    try:
-        description = unicodedata.name(character)  # type: str
-    except ValueError:
-        return False
-    return "LATIN" in description
-
-
-def is_ascii(character: str) -> bool:
-    try:
-        character.encode("ascii")
-    except UnicodeEncodeError:
-        return False
-    return True
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_punctuation(character: str) -> bool:
-    character_category = unicodedata.category(character)  # type: str
-
-    if "P" in character_category:
-        return True
-
-    character_range = unicode_range(character)  # type: Optional[str]
-
-    if character_range is None:
-        return False
-
-    return "Punctuation" in character_range
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_symbol(character: str) -> bool:
-    character_category = unicodedata.category(character)  # type: str
-
-    if "S" in character_category or "N" in character_category:
-        return True
-
-    character_range = unicode_range(character)  # type: Optional[str]
-
-    if character_range is None:
-        return False
-
-    return "Forms" in character_range
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_separator(character: str) -> bool:
-    if character.isspace() or character in ["｜", "+", ",", ";", "<", ">"]:
-        return True
-
-    character_category = unicodedata.category(character)  # type: str
-
-    return "Z" in character_category
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_case_variable(character: str) -> bool:
-    return character.islower() != character.isupper()
-
-
-def is_private_use_only(character: str) -> bool:
-    character_category = unicodedata.category(character)  # type: str
-
-    return "Co" == character_category
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_cjk(character: str) -> bool:
-    try:
-        character_name = unicodedata.name(character)
-    except ValueError:
-        return False
-
-    return "CJK" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_hiragana(character: str) -> bool:
-    try:
-        character_name = unicodedata.name(character)
-    except ValueError:
-        return False
-
-    return "HIRAGANA" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_katakana(character: str) -> bool:
-    try:
-        character_name = unicodedata.name(character)
-    except ValueError:
-        return False
-
-    return "KATAKANA" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_hangul(character: str) -> bool:
-    try:
-        character_name = unicodedata.name(character)
-    except ValueError:
-        return False
-
-    return "HANGUL" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_thai(character: str) -> bool:
-    try:
-        character_name = unicodedata.name(character)
-    except ValueError:
-        return False
-
-    return "THAI" in character_name
-
-
-@lru_cache(maxsize=len(UNICODE_RANGES_COMBINED))
-def is_unicode_range_secondary(range_name: str) -> bool:
-    for keyword in UNICODE_SECONDARY_RANGE_KEYWORD:
-        if keyword in range_name:
-            return True
-
-    return False
-
-
-def any_specified_encoding(sequence: bytes, search_zone: int = 4096) -> Optional[str]:
-    """
-    Extract using ASCII-only decoder any specified encoding in the first n-bytes.
-    """
-    if not isinstance(sequence, bytes):
-        raise TypeError
-
-    seq_len = len(sequence)  # type: int
-
-    results = findall(
-        RE_POSSIBLE_ENCODING_INDICATION,
-        sequence[: seq_len if seq_len <= search_zone else search_zone].decode(
-            "ascii", errors="ignore"
-        ),
-    )  # type: List[str]
-
-    if len(results) == 0:
-        return None
-
-    for specified_encoding in results:
-        specified_encoding = specified_encoding.lower().replace("-", "_")
-
-        for encoding_alias, encoding_iana in aliases.items():
-            if encoding_alias == specified_encoding:
-                return encoding_iana
-            if encoding_iana == specified_encoding:
-                return encoding_iana
-
-    return None
-
-
-@lru_cache(maxsize=128)
-def is_multi_byte_encoding(name: str) -> bool:
-    """
-    Verify is a specific encoding is a multi byte one based on it IANA name
-    """
-    return name in {
-        "utf_8",
-        "utf_8_sig",
-        "utf_16",
-        "utf_16_be",
-        "utf_16_le",
-        "utf_32",
-        "utf_32_le",
-        "utf_32_be",
-        "utf_7",
-    } or issubclass(
-        importlib.import_module("encodings.{}".format(name)).IncrementalDecoder,  # type: ignore
-        MultibyteIncrementalDecoder,
-    )
-
-
-def identify_sig_or_bom(sequence: bytes) -> Tuple[Optional[str], bytes]:
-    """
-    Identify and extract SIG/BOM in given sequence.
-    """
-
-    for iana_encoding in ENCODING_MARKS:
-        marks = ENCODING_MARKS[iana_encoding]  # type: Union[bytes, List[bytes]]
-
-        if isinstance(marks, bytes):
-            marks = [marks]
-
-        for mark in marks:
-            if sequence.startswith(mark):
-                return iana_encoding, mark
-
-    return None, b""
-
-
-def should_strip_sig_or_bom(iana_encoding: str) -> bool:
-    return iana_encoding not in {"utf_16", "utf_32"}
-
-
-def iana_name(cp_name: str, strict: bool = True) -> str:
-    cp_name = cp_name.lower().replace("-", "_")
-
-    for encoding_alias, encoding_iana in aliases.items():
-        if cp_name == encoding_alias or cp_name == encoding_iana:
-            return encoding_iana
-
-    if strict:
-        raise ValueError("Unable to retrieve IANA for '{}'".format(cp_name))
-
-    return cp_name
-
-
-def range_scan(decoded_sequence: str) -> List[str]:
-    ranges = set()  # type: Set[str]
-
-    for character in decoded_sequence:
-        character_range = unicode_range(character)  # type: Optional[str]
-
-        if character_range is None:
-            continue
-
-        ranges.add(character_range)
-
-    return list(ranges)
-
-
-def cp_similarity(iana_name_a: str, iana_name_b: str) -> float:
-
-    if is_multi_byte_encoding(iana_name_a) or is_multi_byte_encoding(iana_name_b):
-        return 0.0
-
-    decoder_a = importlib.import_module("encodings.{}".format(iana_name_a)).IncrementalDecoder  # type: ignore
-    decoder_b = importlib.import_module("encodings.{}".format(iana_name_b)).IncrementalDecoder  # type: ignore
-
-    id_a = decoder_a(errors="ignore")  # type: IncrementalDecoder
-    id_b = decoder_b(errors="ignore")  # type: IncrementalDecoder
-
-    character_match_count = 0  # type: int
-
-    for i in range(0, 255):
-        to_be_decoded = bytes([i])  # type: bytes
-        if id_a.decode(to_be_decoded) == id_b.decode(to_be_decoded):
-            character_match_count += 1
-
-    return character_match_count / 254
-
-
-def is_cp_similar(iana_name_a: str, iana_name_b: str) -> bool:
-    """
-    Determine if two code page are at least 80% similar. IANA_SUPPORTED_SIMILAR dict was generated using
-    the function cp_similarity.
-    """
-    return (
-        iana_name_a in IANA_SUPPORTED_SIMILAR
-        and iana_name_b in IANA_SUPPORTED_SIMILAR[iana_name_a]
-    )
diff --git a/addon/globalPlugins/spellcheck/libs/charset_normalizer/version.py b/addon/globalPlugins/spellcheck/libs/charset_normalizer/version.py
deleted file mode 100644
index d8c2fd1..0000000
--- a/addon/globalPlugins/spellcheck/libs/charset_normalizer/version.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""
-Expose version
-"""
-
-__version__ = "2.0.4"
-VERSION = __version__.split(".")
diff --git a/addon/globalPlugins/spellcheck/libs/concurrent/__init__.py b/addon/globalPlugins/spellcheck/libs/concurrent/__init__.py
deleted file mode 100644
index 196d378..0000000
--- a/addon/globalPlugins/spellcheck/libs/concurrent/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# This directory is a Python package.
diff --git a/addon/globalPlugins/spellcheck/libs/concurrent/futures/__init__.py b/addon/globalPlugins/spellcheck/libs/concurrent/futures/__init__.py
deleted file mode 100644
index 91ab984..0000000
--- a/addon/globalPlugins/spellcheck/libs/concurrent/futures/__init__.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright 2009 Brian Quinlan. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-"""Execute computations asynchronously using threads or processes."""
-
-__author__ = "Brian Quinlan (brian@sweetapp.com)"
-
-from concurrent.futures._base import (
-    FIRST_COMPLETED,
-    FIRST_EXCEPTION,
-    ALL_COMPLETED,
-    CancelledError,
-    TimeoutError,
-    BrokenExecutor,
-    Future,
-    Executor,
-    wait,
-    as_completed,
-)
-
-__all__ = (
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "CancelledError",
-    "TimeoutError",
-    "BrokenExecutor",
-    "Future",
-    "Executor",
-    "wait",
-    "as_completed",
-    "ProcessPoolExecutor",
-    "ThreadPoolExecutor",
-)
-
-
-def __dir__():
-    return __all__ + ("__author__", "__doc__")
-
-
-def __getattr__(name):
-    global ProcessPoolExecutor, ThreadPoolExecutor
-
-    if name == "ProcessPoolExecutor":
-        from .process import ProcessPoolExecutor as pe
-
-        ProcessPoolExecutor = pe
-        return pe
-
-    if name == "ThreadPoolExecutor":
-        from .thread import ThreadPoolExecutor as te
-
-        ThreadPoolExecutor = te
-        return te
-
-    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/addon/globalPlugins/spellcheck/libs/concurrent/futures/_base.py b/addon/globalPlugins/spellcheck/libs/concurrent/futures/_base.py
deleted file mode 100644
index cbed2bf..0000000
--- a/addon/globalPlugins/spellcheck/libs/concurrent/futures/_base.py
+++ /dev/null
@@ -1,645 +0,0 @@
-# Copyright 2009 Brian Quinlan. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-__author__ = "Brian Quinlan (brian@sweetapp.com)"
-
-import collections
-import logging
-import threading
-import time
-
-FIRST_COMPLETED = "FIRST_COMPLETED"
-FIRST_EXCEPTION = "FIRST_EXCEPTION"
-ALL_COMPLETED = "ALL_COMPLETED"
-_AS_COMPLETED = "_AS_COMPLETED"
-
-# Possible future states (for internal use by the futures package).
-PENDING = "PENDING"
-RUNNING = "RUNNING"
-# The future was cancelled by the user...
-CANCELLED = "CANCELLED"
-# ...and _Waiter.add_cancelled() was called by a worker.
-CANCELLED_AND_NOTIFIED = "CANCELLED_AND_NOTIFIED"
-FINISHED = "FINISHED"
-
-_FUTURE_STATES = [PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]
-
-_STATE_TO_DESCRIPTION_MAP = {
-    PENDING: "pending",
-    RUNNING: "running",
-    CANCELLED: "cancelled",
-    CANCELLED_AND_NOTIFIED: "cancelled",
-    FINISHED: "finished",
-}
-
-# Logger for internal use by the futures package.
-LOGGER = logging.getLogger("concurrent.futures")
-
-
-class Error(Exception):
-    """Base class for all future-related exceptions."""
-
-    pass
-
-
-class CancelledError(Error):
-    """The Future was cancelled."""
-
-    pass
-
-
-class TimeoutError(Error):
-    """The operation exceeded the given deadline."""
-
-    pass
-
-
-class _Waiter(object):
-    """Provides the event that wait() and as_completed() block on."""
-
-    def __init__(self):
-        self.event = threading.Event()
-        self.finished_futures = []
-
-    def add_result(self, future):
-        self.finished_futures.append(future)
-
-    def add_exception(self, future):
-        self.finished_futures.append(future)
-
-    def add_cancelled(self, future):
-        self.finished_futures.append(future)
-
-
-class _AsCompletedWaiter(_Waiter):
-    """Used by as_completed()."""
-
-    def __init__(self):
-        super(_AsCompletedWaiter, self).__init__()
-        self.lock = threading.Lock()
-
-    def add_result(self, future):
-        with self.lock:
-            super(_AsCompletedWaiter, self).add_result(future)
-            self.event.set()
-
-    def add_exception(self, future):
-        with self.lock:
-            super(_AsCompletedWaiter, self).add_exception(future)
-            self.event.set()
-
-    def add_cancelled(self, future):
-        with self.lock:
-            super(_AsCompletedWaiter, self).add_cancelled(future)
-            self.event.set()
-
-
-class _FirstCompletedWaiter(_Waiter):
-    """Used by wait(return_when=FIRST_COMPLETED)."""
-
-    def add_result(self, future):
-        super().add_result(future)
-        self.event.set()
-
-    def add_exception(self, future):
-        super().add_exception(future)
-        self.event.set()
-
-    def add_cancelled(self, future):
-        super().add_cancelled(future)
-        self.event.set()
-
-
-class _AllCompletedWaiter(_Waiter):
-    """Used by wait(return_when=FIRST_EXCEPTION and ALL_COMPLETED)."""
-
-    def __init__(self, num_pending_calls, stop_on_exception):
-        self.num_pending_calls = num_pending_calls
-        self.stop_on_exception = stop_on_exception
-        self.lock = threading.Lock()
-        super().__init__()
-
-    def _decrement_pending_calls(self):
-        with self.lock:
-            self.num_pending_calls -= 1
-            if not self.num_pending_calls:
-                self.event.set()
-
-    def add_result(self, future):
-        super().add_result(future)
-        self._decrement_pending_calls()
-
-    def add_exception(self, future):
-        super().add_exception(future)
-        if self.stop_on_exception:
-            self.event.set()
-        else:
-            self._decrement_pending_calls()
-
-    def add_cancelled(self, future):
-        super().add_cancelled(future)
-        self._decrement_pending_calls()
-
-
-class _AcquireFutures(object):
-    """A context manager that does an ordered acquire of Future conditions."""
-
-    def __init__(self, futures):
-        self.futures = sorted(futures, key=id)
-
-    def __enter__(self):
-        for future in self.futures:
-            future._condition.acquire()
-
-    def __exit__(self, *args):
-        for future in self.futures:
-            future._condition.release()
-
-
-def _create_and_install_waiters(fs, return_when):
-    if return_when == _AS_COMPLETED:
-        waiter = _AsCompletedWaiter()
-    elif return_when == FIRST_COMPLETED:
-        waiter = _FirstCompletedWaiter()
-    else:
-        pending_count = sum(
-            f._state not in [CANCELLED_AND_NOTIFIED, FINISHED] for f in fs
-        )
-
-        if return_when == FIRST_EXCEPTION:
-            waiter = _AllCompletedWaiter(pending_count, stop_on_exception=True)
-        elif return_when == ALL_COMPLETED:
-            waiter = _AllCompletedWaiter(pending_count, stop_on_exception=False)
-        else:
-            raise ValueError("Invalid return condition: %r" % return_when)
-
-    for f in fs:
-        f._waiters.append(waiter)
-
-    return waiter
-
-
-def _yield_finished_futures(fs, waiter, ref_collect):
-    """
-    Iterate on the list *fs*, yielding finished futures one by one in
-    reverse order.
-    Before yielding a future, *waiter* is removed from its waiters
-    and the future is removed from each set in the collection of sets
-    *ref_collect*.
-
-    The aim of this function is to avoid keeping stale references after
-    the future is yielded and before the iterator resumes.
-    """
-    while fs:
-        f = fs[-1]
-        for futures_set in ref_collect:
-            futures_set.remove(f)
-        with f._condition:
-            f._waiters.remove(waiter)
-        del f
-        # Careful not to keep a reference to the popped value
-        yield fs.pop()
-
-
-def as_completed(fs, timeout=None):
-    """An iterator over the given futures that yields each as it completes.
-
-    Args:
-        fs: The sequence of Futures (possibly created by different Executors) to
-            iterate over.
-        timeout: The maximum number of seconds to wait. If None, then there
-            is no limit on the wait time.
-
-    Returns:
-        An iterator that yields the given Futures as they complete (finished or
-        cancelled). If any given Futures are duplicated, they will be returned
-        once.
-
-    Raises:
-        TimeoutError: If the entire result iterator could not be generated
-            before the given timeout.
-    """
-    if timeout is not None:
-        end_time = timeout + time.monotonic()
-
-    fs = set(fs)
-    total_futures = len(fs)
-    with _AcquireFutures(fs):
-        finished = set(f for f in fs if f._state in [CANCELLED_AND_NOTIFIED, FINISHED])
-        pending = fs - finished
-        waiter = _create_and_install_waiters(fs, _AS_COMPLETED)
-    finished = list(finished)
-    try:
-        yield from _yield_finished_futures(finished, waiter, ref_collect=(fs,))
-
-        while pending:
-            if timeout is None:
-                wait_timeout = None
-            else:
-                wait_timeout = end_time - time.monotonic()
-                if wait_timeout < 0:
-                    raise TimeoutError(
-                        "%d (of %d) futures unfinished" % (len(pending), total_futures)
-                    )
-
-            waiter.event.wait(wait_timeout)
-
-            with waiter.lock:
-                finished = waiter.finished_futures
-                waiter.finished_futures = []
-                waiter.event.clear()
-
-            # reverse to keep finishing order
-            finished.reverse()
-            yield from _yield_finished_futures(
-                finished, waiter, ref_collect=(fs, pending)
-            )
-
-    finally:
-        # Remove waiter from unfinished futures
-        for f in fs:
-            with f._condition:
-                f._waiters.remove(waiter)
-
-
-DoneAndNotDoneFutures = collections.namedtuple("DoneAndNotDoneFutures", "done not_done")
-
-
-def wait(fs, timeout=None, return_when=ALL_COMPLETED):
-    """Wait for the futures in the given sequence to complete.
-
-    Args:
-        fs: The sequence of Futures (possibly created by different Executors) to
-            wait upon.
-        timeout: The maximum number of seconds to wait. If None, then there
-            is no limit on the wait time.
-        return_when: Indicates when this function should return. The options
-            are:
-
-            FIRST_COMPLETED - Return when any future finishes or is
-                              cancelled.
-            FIRST_EXCEPTION - Return when any future finishes by raising an
-                              exception. If no future raises an exception
-                              then it is equivalent to ALL_COMPLETED.
-            ALL_COMPLETED -   Return when all futures finish or are cancelled.
-
-    Returns:
-        A named 2-tuple of sets. The first set, named 'done', contains the
-        futures that completed (is finished or cancelled) before the wait
-        completed. The second set, named 'not_done', contains uncompleted
-        futures.
-    """
-    with _AcquireFutures(fs):
-        done = set(f for f in fs if f._state in [CANCELLED_AND_NOTIFIED, FINISHED])
-        not_done = set(fs) - done
-
-        if (return_when == FIRST_COMPLETED) and done:
-            return DoneAndNotDoneFutures(done, not_done)
-        elif (return_when == FIRST_EXCEPTION) and done:
-            if any(f for f in done if not f.cancelled() and f.exception() is not None):
-                return DoneAndNotDoneFutures(done, not_done)
-
-        if len(done) == len(fs):
-            return DoneAndNotDoneFutures(done, not_done)
-
-        waiter = _create_and_install_waiters(fs, return_when)
-
-    waiter.event.wait(timeout)
-    for f in fs:
-        with f._condition:
-            f._waiters.remove(waiter)
-
-    done.update(waiter.finished_futures)
-    return DoneAndNotDoneFutures(done, set(fs) - done)
-
-
-class Future(object):
-    """Represents the result of an asynchronous computation."""
-
-    def __init__(self):
-        """Initializes the future. Should not be called by clients."""
-        self._condition = threading.Condition()
-        self._state = PENDING
-        self._result = None
-        self._exception = None
-        self._waiters = []
-        self._done_callbacks = []
-
-    def _invoke_callbacks(self):
-        for callback in self._done_callbacks:
-            try:
-                callback(self)
-            except Exception:
-                LOGGER.exception("exception calling callback for %r", self)
-
-    def __repr__(self):
-        with self._condition:
-            if self._state == FINISHED:
-                if self._exception:
-                    return "<%s at %#x state=%s raised %s>" % (
-                        self.__class__.__name__,
-                        id(self),
-                        _STATE_TO_DESCRIPTION_MAP[self._state],
-                        self._exception.__class__.__name__,
-                    )
-                else:
-                    return "<%s at %#x state=%s returned %s>" % (
-                        self.__class__.__name__,
-                        id(self),
-                        _STATE_TO_DESCRIPTION_MAP[self._state],
-                        self._result.__class__.__name__,
-                    )
-            return "<%s at %#x state=%s>" % (
-                self.__class__.__name__,
-                id(self),
-                _STATE_TO_DESCRIPTION_MAP[self._state],
-            )
-
-    def cancel(self):
-        """Cancel the future if possible.
-
-        Returns True if the future was cancelled, False otherwise. A future
-        cannot be cancelled if it is running or has already completed.
-        """
-        with self._condition:
-            if self._state in [RUNNING, FINISHED]:
-                return False
-
-            if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:
-                return True
-
-            self._state = CANCELLED
-            self._condition.notify_all()
-
-        self._invoke_callbacks()
-        return True
-
-    def cancelled(self):
-        """Return True if the future was cancelled."""
-        with self._condition:
-            return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]
-
-    def running(self):
-        """Return True if the future is currently executing."""
-        with self._condition:
-            return self._state == RUNNING
-
-    def done(self):
-        """Return True of the future was cancelled or finished executing."""
-        with self._condition:
-            return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]
-
-    def __get_result(self):
-        if self._exception:
-            raise self._exception
-        else:
-            return self._result
-
-    def add_done_callback(self, fn):
-        """Attaches a callable that will be called when the future finishes.
-
-        Args:
-            fn: A callable that will be called with this future as its only
-                argument when the future completes or is cancelled. The callable
-                will always be called by a thread in the same process in which
-                it was added. If the future has already completed or been
-                cancelled then the callable will be called immediately. These
-                callables are called in the order that they were added.
-        """
-        with self._condition:
-            if self._state not in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]:
-                self._done_callbacks.append(fn)
-                return
-        try:
-            fn(self)
-        except Exception:
-            LOGGER.exception("exception calling callback for %r", self)
-
-    def result(self, timeout=None):
-        """Return the result of the call that the future represents.
-
-        Args:
-            timeout: The number of seconds to wait for the result if the future
-                isn't done. If None, then there is no limit on the wait time.
-
-        Returns:
-            The result of the call that the future represents.
-
-        Raises:
-            CancelledError: If the future was cancelled.
-            TimeoutError: If the future didn't finish executing before the given
-                timeout.
-            Exception: If the call raised then that exception will be raised.
-        """
-        with self._condition:
-            if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:
-                raise CancelledError()
-            elif self._state == FINISHED:
-                return self.__get_result()
-
-            self._condition.wait(timeout)
-
-            if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:
-                raise CancelledError()
-            elif self._state == FINISHED:
-                return self.__get_result()
-            else:
-                raise TimeoutError()
-
-    def exception(self, timeout=None):
-        """Return the exception raised by the call that the future represents.
-
-        Args:
-            timeout: The number of seconds to wait for the exception if the
-                future isn't done. If None, then there is no limit on the wait
-                time.
-
-        Returns:
-            The exception raised by the call that the future represents or None
-            if the call completed without raising.
-
-        Raises:
-            CancelledError: If the future was cancelled.
-            TimeoutError: If the future didn't finish executing before the given
-                timeout.
-        """
-
-        with self._condition:
-            if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:
-                raise CancelledError()
-            elif self._state == FINISHED:
-                return self._exception
-
-            self._condition.wait(timeout)
-
-            if self._state in [CANCELLED, CANCELLED_AND_NOTIFIED]:
-                raise CancelledError()
-            elif self._state == FINISHED:
-                return self._exception
-            else:
-                raise TimeoutError()
-
-    # The following methods should only be used by Executors and in tests.
-    def set_running_or_notify_cancel(self):
-        """Mark the future as running or process any cancel notifications.
-
-        Should only be used by Executor implementations and unit tests.
-
-        If the future has been cancelled (cancel() was called and returned
-        True) then any threads waiting on the future completing (though calls
-        to as_completed() or wait()) are notified and False is returned.
-
-        If the future was not cancelled then it is put in the running state
-        (future calls to running() will return True) and True is returned.
-
-        This method should be called by Executor implementations before
-        executing the work associated with this future. If this method returns
-        False then the work should not be executed.
-
-        Returns:
-            False if the Future was cancelled, True otherwise.
-
-        Raises:
-            RuntimeError: if this method was already called or if set_result()
-                or set_exception() was called.
-        """
-        with self._condition:
-            if self._state == CANCELLED:
-                self._state = CANCELLED_AND_NOTIFIED
-                for waiter in self._waiters:
-                    waiter.add_cancelled(self)
-                # self._condition.notify_all() is not necessary because
-                # self.cancel() triggers a notification.
-                return False
-            elif self._state == PENDING:
-                self._state = RUNNING
-                return True
-            else:
-                LOGGER.critical(
-                    "Future %s in unexpected state: %s", id(self), self._state
-                )
-                raise RuntimeError("Future in unexpected state")
-
-    def set_result(self, result):
-        """Sets the return value of work associated with the future.
-
-        Should only be used by Executor implementations and unit tests.
-        """
-        with self._condition:
-            self._result = result
-            self._state = FINISHED
-            for waiter in self._waiters:
-                waiter.add_result(self)
-            self._condition.notify_all()
-        self._invoke_callbacks()
-
-    def set_exception(self, exception):
-        """Sets the result of the future as being the given exception.
-
-        Should only be used by Executor implementations and unit tests.
-        """
-        with self._condition:
-            self._exception = exception
-            self._state = FINISHED
-            for waiter in self._waiters:
-                waiter.add_exception(self)
-            self._condition.notify_all()
-        self._invoke_callbacks()
-
-
-class Executor(object):
-    """This is an abstract base class for concrete asynchronous executors."""
-
-    def submit(*args, **kwargs):
-        """Submits a callable to be executed with the given arguments.
-
-        Schedules the callable to be executed as fn(*args, **kwargs) and returns
-        a Future instance representing the execution of the callable.
-
-        Returns:
-            A Future representing the given call.
-        """
-        if len(args) >= 2:
-            pass
-        elif not args:
-            raise TypeError(
-                "descriptor 'submit' of 'Executor' object " "needs an argument"
-            )
-        elif "fn" not in kwargs:
-            raise TypeError(
-                "submit expected at least 1 positional argument, "
-                "got %d" % (len(args) - 1)
-            )
-
-        raise NotImplementedError()
-
-    def map(self, fn, *iterables, timeout=None, chunksize=1):
-        """Returns an iterator equivalent to map(fn, iter).
-
-        Args:
-            fn: A callable that will take as many arguments as there are
-                passed iterables.
-            timeout: The maximum number of seconds to wait. If None, then there
-                is no limit on the wait time.
-            chunksize: The size of the chunks the iterable will be broken into
-                before being passed to a child process. This argument is only
-                used by ProcessPoolExecutor; it is ignored by
-                ThreadPoolExecutor.
-
-        Returns:
-            An iterator equivalent to: map(func, *iterables) but the calls may
-            be evaluated out-of-order.
-
-        Raises:
-            TimeoutError: If the entire result iterator could not be generated
-                before the given timeout.
-            Exception: If fn(*args) raises for any values.
-        """
-        if timeout is not None:
-            end_time = timeout + time.monotonic()
-
-        fs = [self.submit(fn, *args) for args in zip(*iterables)]
-
-        # Yield must be hidden in closure so that the futures are submitted
-        # before the first iterator value is required.
-        def result_iterator():
-            try:
-                # reverse to keep finishing order
-                fs.reverse()
-                while fs:
-                    # Careful not to keep a reference to the popped future
-                    if timeout is None:
-                        yield fs.pop().result()
-                    else:
-                        yield fs.pop().result(end_time - time.monotonic())
-            finally:
-                for future in fs:
-                    future.cancel()
-
-        return result_iterator()
-
-    def shutdown(self, wait=True):
-        """Clean-up the resources associated with the Executor.
-
-        It is safe to call this method several times. Otherwise, no other
-        methods can be called after this one.
-
-        Args:
-            wait: If True then shutdown will not return until all running
-                futures have finished executing and the resources used by the
-                executor have been reclaimed.
-        """
-        pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.shutdown(wait=True)
-        return False
-
-
-class BrokenExecutor(RuntimeError):
-    """
-    Raised when a executor has become non-functional after a severe failure.
-    """
diff --git a/addon/globalPlugins/spellcheck/libs/concurrent/futures/process.py b/addon/globalPlugins/spellcheck/libs/concurrent/futures/process.py
deleted file mode 100644
index 28692ea..0000000
--- a/addon/globalPlugins/spellcheck/libs/concurrent/futures/process.py
+++ /dev/null
@@ -1,727 +0,0 @@
-# Copyright 2009 Brian Quinlan. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-"""Implements ProcessPoolExecutor.
-
-The follow diagram and text describe the data-flow through the system:
-
-|======================= In-process =====================|== Out-of-process ==|
-
-+----------+     +----------+       +--------+     +-----------+    +---------+
-|          |  => | Work Ids |       |        |     | Call Q    |    | Process |
-|          |     +----------+       |        |     +-----------+    |  Pool   |
-|          |     | ...      |       |        |     | ...       |    +---------+
-|          |     | 6        |    => |        |  => | 5, call() | => |         |
-|          |     | 7        |       |        |     | ...       |    |         |
-| Process  |     | ...      |       | Local  |     +-----------+    | Process |
-|  Pool    |     +----------+       | Worker |                      |  #1..n  |
-| Executor |                        | Thread |                      |         |
-|          |     +----------- +     |        |     +-----------+    |         |
-|          | <=> | Work Items | <=> |        | <=  | Result Q  | <= |         |
-|          |     +------------+     |        |     +-----------+    |         |
-|          |     | 6: call()  |     |        |     | ...       |    |         |
-|          |     |    future  |     |        |     | 4, result |    |         |
-|          |     | ...        |     |        |     | 3, except |    |         |
-+----------+     +------------+     +--------+     +-----------+    +---------+
-
-Executor.submit() called:
-- creates a uniquely numbered _WorkItem and adds it to the "Work Items" dict
-- adds the id of the _WorkItem to the "Work Ids" queue
-
-Local worker thread:
-- reads work ids from the "Work Ids" queue and looks up the corresponding
-  WorkItem from the "Work Items" dict: if the work item has been cancelled then
-  it is simply removed from the dict, otherwise it is repackaged as a
-  _CallItem and put in the "Call Q". New _CallItems are put in the "Call Q"
-  until "Call Q" is full. NOTE: the size of the "Call Q" is kept small because
-  calls placed in the "Call Q" can no longer be cancelled with Future.cancel().
-- reads _ResultItems from "Result Q", updates the future stored in the
-  "Work Items" dict and deletes the dict entry
-
-Process #1..n:
-- reads _CallItems from "Call Q", executes the calls, and puts the resulting
-  _ResultItems in "Result Q"
-"""
-
-__author__ = "Brian Quinlan (brian@sweetapp.com)"
-
-import atexit
-import os
-from concurrent.futures import _base
-import queue
-from queue import Full
-import multiprocessing as mp
-from multiprocessing.connection import wait
-from multiprocessing.queues import Queue
-import threading
-import weakref
-from functools import partial
-import itertools
-import sys
-import traceback
-
-# Workers are created as daemon threads and processes. This is done to allow the
-# interpreter to exit when there are still idle processes in a
-# ProcessPoolExecutor's process pool (i.e. shutdown() was not called). However,
-# allowing workers to die with the interpreter has two undesirable properties:
-#   - The workers would still be running during interpreter shutdown,
-#     meaning that they would fail in unpredictable ways.
-#   - The workers could be killed while evaluating a work item, which could
-#     be bad if the callable being evaluated has external side-effects e.g.
-#     writing to a file.
-#
-# To work around this problem, an exit handler is installed which tells the
-# workers to exit when their work queues are empty and then waits until the
-# threads/processes finish.
-
-_threads_wakeups = weakref.WeakKeyDictionary()
-_global_shutdown = False
-
-
-class _ThreadWakeup:
-    def __init__(self):
-        self._reader, self._writer = mp.Pipe(duplex=False)
-
-    def close(self):
-        self._writer.close()
-        self._reader.close()
-
-    def wakeup(self):
-        self._writer.send_bytes(b"")
-
-    def clear(self):
-        while self._reader.poll():
-            self._reader.recv_bytes()
-
-
-def _python_exit():
-    global _global_shutdown
-    _global_shutdown = True
-    items = list(_threads_wakeups.items())
-    for _, thread_wakeup in items:
-        thread_wakeup.wakeup()
-    for t, _ in items:
-        t.join()
-
-
-# Controls how many more calls than processes will be queued in the call queue.
-# A smaller number will mean that processes spend more time idle waiting for
-# work while a larger number will make Future.cancel() succeed less frequently
-# (Futures in the call queue cannot be cancelled).
-EXTRA_QUEUED_CALLS = 1
-
-
-# On Windows, WaitForMultipleObjects is used to wait for processes to finish.
-# It can wait on, at most, 63 objects. There is an overhead of two objects:
-# - the result queue reader
-# - the thread wakeup reader
-_MAX_WINDOWS_WORKERS = 63 - 2
-
-# Hack to embed stringification of remote traceback in local traceback
-
-
-class _RemoteTraceback(Exception):
-    def __init__(self, tb):
-        self.tb = tb
-
-    def __str__(self):
-        return self.tb
-
-
-class _ExceptionWithTraceback:
-    def __init__(self, exc, tb):
-        tb = traceback.format_exception(type(exc), exc, tb)
-        tb = "".join(tb)
-        self.exc = exc
-        self.tb = '\n"""\n%s"""' % tb
-
-    def __reduce__(self):
-        return _rebuild_exc, (self.exc, self.tb)
-
-
-def _rebuild_exc(exc, tb):
-    exc.__cause__ = _RemoteTraceback(tb)
-    return exc
-
-
-class _WorkItem(object):
-    def __init__(self, future, fn, args, kwargs):
-        self.future = future
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-
-
-class _ResultItem(object):
-    def __init__(self, work_id, exception=None, result=None):
-        self.work_id = work_id
-        self.exception = exception
-        self.result = result
-
-
-class _CallItem(object):
-    def __init__(self, work_id, fn, args, kwargs):
-        self.work_id = work_id
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-
-
-class _SafeQueue(Queue):
-    """Safe Queue set exception to the future object linked to a job"""
-
-    def __init__(self, max_size=0, *, ctx, pending_work_items):
-        self.pending_work_items = pending_work_items
-        super().__init__(max_size, ctx=ctx)
-
-    def _on_queue_feeder_error(self, e, obj):
-        if isinstance(obj, _CallItem):
-            tb = traceback.format_exception(type(e), e, e.__traceback__)
-            e.__cause__ = _RemoteTraceback('\n"""\n{}"""'.format("".join(tb)))
-            work_item = self.pending_work_items.pop(obj.work_id, None)
-            # work_item can be None if another process terminated. In this case,
-            # the queue_manager_thread fails all work_items with BrokenProcessPool
-            if work_item is not None:
-                work_item.future.set_exception(e)
-        else:
-            super()._on_queue_feeder_error(e, obj)
-
-
-def _get_chunks(*iterables, chunksize):
-    """Iterates over zip()ed iterables in chunks."""
-    it = zip(*iterables)
-    while True:
-        chunk = tuple(itertools.islice(it, chunksize))
-        if not chunk:
-            return
-        yield chunk
-
-
-def _process_chunk(fn, chunk):
-    """Processes a chunk of an iterable passed to map.
-
-    Runs the function passed to map() on a chunk of the
-    iterable passed to map.
-
-    This function is run in a separate process.
-
-    """
-    return [fn(*args) for args in chunk]
-
-
-def _sendback_result(result_queue, work_id, result=None, exception=None):
-    """Safely send back the given result or exception"""
-    try:
-        result_queue.put(_ResultItem(work_id, result=result, exception=exception))
-    except BaseException as e:
-        exc = _ExceptionWithTraceback(e, e.__traceback__)
-        result_queue.put(_ResultItem(work_id, exception=exc))
-
-
-def _process_worker(call_queue, result_queue, initializer, initargs):
-    """Evaluates calls from call_queue and places the results in result_queue.
-
-    This worker is run in a separate process.
-
-    Args:
-        call_queue: A ctx.Queue of _CallItems that will be read and
-            evaluated by the worker.
-        result_queue: A ctx.Queue of _ResultItems that will written
-            to by the worker.
-        initializer: A callable initializer, or None
-        initargs: A tuple of args for the initializer
-    """
-    if initializer is not None:
-        try:
-            initializer(*initargs)
-        except BaseException:
-            _base.LOGGER.critical("Exception in initializer:", exc_info=True)
-            # The parent will notice that the process stopped and
-            # mark the pool broken
-            return
-    while True:
-        call_item = call_queue.get(block=True)
-        if call_item is None:
-            # Wake up queue management thread
-            result_queue.put(os.getpid())
-            return
-        try:
-            r = call_item.fn(*call_item.args, **call_item.kwargs)
-        except BaseException as e:
-            exc = _ExceptionWithTraceback(e, e.__traceback__)
-            _sendback_result(result_queue, call_item.work_id, exception=exc)
-        else:
-            _sendback_result(result_queue, call_item.work_id, result=r)
-
-        # Liberate the resource as soon as possible, to avoid holding onto
-        # open files or shared memory that is not needed anymore
-        del call_item
-
-
-def _add_call_item_to_queue(pending_work_items, work_ids, call_queue):
-    """Fills call_queue with _WorkItems from pending_work_items.
-
-    This function never blocks.
-
-    Args:
-        pending_work_items: A dict mapping work ids to _WorkItems e.g.
-            {5: <_WorkItem...>, 6: <_WorkItem...>, ...}
-        work_ids: A queue.Queue of work ids e.g. Queue([5, 6, ...]). Work ids
-            are consumed and the corresponding _WorkItems from
-            pending_work_items are transformed into _CallItems and put in
-            call_queue.
-        call_queue: A multiprocessing.Queue that will be filled with _CallItems
-            derived from _WorkItems.
-    """
-    while True:
-        if call_queue.full():
-            return
-        try:
-            work_id = work_ids.get(block=False)
-        except queue.Empty:
-            return
-        else:
-            work_item = pending_work_items[work_id]
-
-            if work_item.future.set_running_or_notify_cancel():
-                call_queue.put(
-                    _CallItem(work_id, work_item.fn, work_item.args, work_item.kwargs),
-                    block=True,
-                )
-            else:
-                del pending_work_items[work_id]
-                continue
-
-
-def _queue_management_worker(
-    executor_reference,
-    processes,
-    pending_work_items,
-    work_ids_queue,
-    call_queue,
-    result_queue,
-    thread_wakeup,
-):
-    """Manages the communication between this process and the worker processes.
-
-    This function is run in a local thread.
-
-    Args:
-        executor_reference: A weakref.ref to the ProcessPoolExecutor that owns
-            this thread. Used to determine if the ProcessPoolExecutor has been
-            garbage collected and that this function can exit.
-        process: A list of the ctx.Process instances used as
-            workers.
-        pending_work_items: A dict mapping work ids to _WorkItems e.g.
-            {5: <_WorkItem...>, 6: <_WorkItem...>, ...}
-        work_ids_queue: A queue.Queue of work ids e.g. Queue([5, 6, ...]).
-        call_queue: A ctx.Queue that will be filled with _CallItems
-            derived from _WorkItems for processing by the process workers.
-        result_queue: A ctx.SimpleQueue of _ResultItems generated by the
-            process workers.
-        thread_wakeup: A _ThreadWakeup to allow waking up the
-            queue_manager_thread from the main Thread and avoid deadlocks
-            caused by permanently locked queues.
-    """
-    executor = None
-
-    def shutting_down():
-        return _global_shutdown or executor is None or executor._shutdown_thread
-
-    def shutdown_worker():
-        # This is an upper bound on the number of children alive.
-        n_children_alive = sum(p.is_alive() for p in processes.values())
-        n_children_to_stop = n_children_alive
-        n_sentinels_sent = 0
-        # Send the right number of sentinels, to make sure all children are
-        # properly terminated.
-        while n_sentinels_sent < n_children_to_stop and n_children_alive > 0:
-            for i in range(n_children_to_stop - n_sentinels_sent):
-                try:
-                    call_queue.put_nowait(None)
-                    n_sentinels_sent += 1
-                except Full:
-                    break
-            n_children_alive = sum(p.is_alive() for p in processes.values())
-
-        # Release the queue's resources as soon as possible.
-        call_queue.close()
-        # If .join() is not called on the created processes then
-        # some ctx.Queue methods may deadlock on Mac OS X.
-        for p in processes.values():
-            p.join()
-
-    result_reader = result_queue._reader
-    wakeup_reader = thread_wakeup._reader
-    readers = [result_reader, wakeup_reader]
-
-    while True:
-        _add_call_item_to_queue(pending_work_items, work_ids_queue, call_queue)
-
-        # Wait for a result to be ready in the result_queue while checking
-        # that all worker processes are still running, or for a wake up
-        # signal send. The wake up signals come either from new tasks being
-        # submitted, from the executor being shutdown/gc-ed, or from the
-        # shutdown of the python interpreter.
-        worker_sentinels = [p.sentinel for p in processes.values()]
-        ready = wait(readers + worker_sentinels)
-
-        cause = None
-        is_broken = True
-        if result_reader in ready:
-            try:
-                result_item = result_reader.recv()
-                is_broken = False
-            except BaseException as e:
-                cause = traceback.format_exception(type(e), e, e.__traceback__)
-
-        elif wakeup_reader in ready:
-            is_broken = False
-            result_item = None
-        thread_wakeup.clear()
-        if is_broken:
-            # Mark the process pool broken so that submits fail right now.
-            executor = executor_reference()
-            if executor is not None:
-                executor._broken = (
-                    "A child process terminated "
-                    "abruptly, the process pool is not "
-                    "usable anymore"
-                )
-                executor._shutdown_thread = True
-                executor = None
-            bpe = BrokenProcessPool(
-                "A process in the process pool was "
-                "terminated abruptly while the future was "
-                "running or pending."
-            )
-            if cause is not None:
-                bpe.__cause__ = _RemoteTraceback(f"\n'''\n{''.join(cause)}'''")
-            # All futures in flight must be marked failed
-            for work_id, work_item in pending_work_items.items():
-                work_item.future.set_exception(bpe)
-                # Delete references to object. See issue16284
-                del work_item
-            pending_work_items.clear()
-            # Terminate remaining workers forcibly: the queues or their
-            # locks may be in a dirty state and block forever.
-            for p in processes.values():
-                p.terminate()
-            shutdown_worker()
-            return
-        if isinstance(result_item, int):
-            # Clean shutdown of a worker using its PID
-            # (avoids marking the executor broken)
-            assert shutting_down()
-            p = processes.pop(result_item)
-            p.join()
-            if not processes:
-                shutdown_worker()
-                return
-        elif result_item is not None:
-            work_item = pending_work_items.pop(result_item.work_id, None)
-            # work_item can be None if another process terminated (see above)
-            if work_item is not None:
-                if result_item.exception:
-                    work_item.future.set_exception(result_item.exception)
-                else:
-                    work_item.future.set_result(result_item.result)
-                # Delete references to object. See issue16284
-                del work_item
-            # Delete reference to result_item
-            del result_item
-
-        # Check whether we should start shutting down.
-        executor = executor_reference()
-        # No more work items can be added if:
-        #   - The interpreter is shutting down OR
-        #   - The executor that owns this worker has been collected OR
-        #   - The executor that owns this worker has been shutdown.
-        if shutting_down():
-            try:
-                # Flag the executor as shutting down as early as possible if it
-                # is not gc-ed yet.
-                if executor is not None:
-                    executor._shutdown_thread = True
-                # Since no new work items can be added, it is safe to shutdown
-                # this thread if there are no pending work items.
-                if not pending_work_items:
-                    shutdown_worker()
-                    return
-            except Full:
-                # This is not a problem: we will eventually be woken up (in
-                # result_queue.get()) and be able to send a sentinel again.
-                pass
-        executor = None
-
-
-_system_limits_checked = False
-_system_limited = None
-
-
-def _check_system_limits():
-    global _system_limits_checked, _system_limited
-    if _system_limits_checked:
-        if _system_limited:
-            raise NotImplementedError(_system_limited)
-    _system_limits_checked = True
-    try:
-        nsems_max = os.sysconf("SC_SEM_NSEMS_MAX")
-    except (AttributeError, ValueError):
-        # sysconf not available or setting not available
-        return
-    if nsems_max == -1:
-        # indetermined limit, assume that limit is determined
-        # by available memory only
-        return
-    if nsems_max >= 256:
-        # minimum number of semaphores available
-        # according to POSIX
-        return
-    _system_limited = (
-        "system provides too few semaphores (%d"
-        " available, 256 necessary)" % nsems_max
-    )
-    raise NotImplementedError(_system_limited)
-
-
-def _chain_from_iterable_of_lists(iterable):
-    """
-    Specialized implementation of itertools.chain.from_iterable.
-    Each item in *iterable* should be a list.  This function is
-    careful not to keep references to yielded objects.
-    """
-    for element in iterable:
-        element.reverse()
-        while element:
-            yield element.pop()
-
-
-class BrokenProcessPool(_base.BrokenExecutor):
-    """
-    Raised when a process in a ProcessPoolExecutor terminated abruptly
-    while a future was in the running state.
-    """
-
-
-class ProcessPoolExecutor(_base.Executor):
-    def __init__(
-        self, max_workers=None, mp_context=None, initializer=None, initargs=()
-    ):
-        """Initializes a new ProcessPoolExecutor instance.
-
-        Args:
-            max_workers: The maximum number of processes that can be used to
-                execute the given calls. If None or not given then as many
-                worker processes will be created as the machine has processors.
-            mp_context: A multiprocessing context to launch the workers. This
-                object should provide SimpleQueue, Queue and Process.
-            initializer: A callable used to initialize worker processes.
-            initargs: A tuple of arguments to pass to the initializer.
-        """
-        _check_system_limits()
-
-        if max_workers is None:
-            self._max_workers = os.cpu_count() or 1
-            if sys.platform == "win32":
-                self._max_workers = min(_MAX_WINDOWS_WORKERS, self._max_workers)
-        else:
-            if max_workers <= 0:
-                raise ValueError("max_workers must be greater than 0")
-            elif sys.platform == "win32" and max_workers > _MAX_WINDOWS_WORKERS:
-                raise ValueError(f"max_workers must be <= {_MAX_WINDOWS_WORKERS}")
-
-            self._max_workers = max_workers
-
-        if mp_context is None:
-            mp_context = mp.get_context()
-        self._mp_context = mp_context
-
-        if initializer is not None and not callable(initializer):
-            raise TypeError("initializer must be a callable")
-        self._initializer = initializer
-        self._initargs = initargs
-
-        # Management thread
-        self._queue_management_thread = None
-
-        # Map of pids to processes
-        self._processes = {}
-
-        # Shutdown is a two-step process.
-        self._shutdown_thread = False
-        self._shutdown_lock = threading.Lock()
-        self._broken = False
-        self._queue_count = 0
-        self._pending_work_items = {}
-
-        # Create communication channels for the executor
-        # Make the call queue slightly larger than the number of processes to
-        # prevent the worker processes from idling. But don't make it too big
-        # because futures in the call queue cannot be cancelled.
-        queue_size = self._max_workers + EXTRA_QUEUED_CALLS
-        self._call_queue = _SafeQueue(
-            max_size=queue_size,
-            ctx=self._mp_context,
-            pending_work_items=self._pending_work_items,
-        )
-        # Killed worker processes can produce spurious "broken pipe"
-        # tracebacks in the queue's own worker thread. But we detect killed
-        # processes anyway, so silence the tracebacks.
-        self._call_queue._ignore_epipe = True
-        self._result_queue = mp_context.SimpleQueue()
-        self._work_ids = queue.Queue()
-
-        # _ThreadWakeup is a communication channel used to interrupt the wait
-        # of the main loop of queue_manager_thread from another thread (e.g.
-        # when calling executor.submit or executor.shutdown). We do not use the
-        # _result_queue to send the wakeup signal to the queue_manager_thread
-        # as it could result in a deadlock if a worker process dies with the
-        # _result_queue write lock still acquired.
-        self._queue_management_thread_wakeup = _ThreadWakeup()
-
-    def _start_queue_management_thread(self):
-        if self._queue_management_thread is None:
-            # When the executor gets garbarge collected, the weakref callback
-            # will wake up the queue management thread so that it can terminate
-            # if there is no pending work item.
-            def weakref_cb(_, thread_wakeup=self._queue_management_thread_wakeup):
-                mp.util.debug(
-                    "Executor collected: triggering callback for" " QueueManager wakeup"
-                )
-                thread_wakeup.wakeup()
-
-            # Start the processes so that their sentinels are known.
-            self._adjust_process_count()
-            self._queue_management_thread = threading.Thread(
-                target=_queue_management_worker,
-                args=(
-                    weakref.ref(self, weakref_cb),
-                    self._processes,
-                    self._pending_work_items,
-                    self._work_ids,
-                    self._call_queue,
-                    self._result_queue,
-                    self._queue_management_thread_wakeup,
-                ),
-                name="QueueManagerThread",
-            )
-            self._queue_management_thread.daemon = True
-            self._queue_management_thread.start()
-            _threads_wakeups[
-                self._queue_management_thread
-            ] = self._queue_management_thread_wakeup
-
-    def _adjust_process_count(self):
-        for _ in range(len(self._processes), self._max_workers):
-            p = self._mp_context.Process(
-                target=_process_worker,
-                args=(
-                    self._call_queue,
-                    self._result_queue,
-                    self._initializer,
-                    self._initargs,
-                ),
-            )
-            p.start()
-            self._processes[p.pid] = p
-
-    def submit(*args, **kwargs):
-        if len(args) >= 2:
-            self, fn, *args = args
-        elif not args:
-            raise TypeError(
-                "descriptor 'submit' of 'ProcessPoolExecutor' object "
-                "needs an argument"
-            )
-        elif "fn" in kwargs:
-            fn = kwargs.pop("fn")
-            self, *args = args
-        else:
-            raise TypeError(
-                "submit expected at least 1 positional argument, "
-                "got %d" % (len(args) - 1)
-            )
-
-        with self._shutdown_lock:
-            if self._broken:
-                raise BrokenProcessPool(self._broken)
-            if self._shutdown_thread:
-                raise RuntimeError("cannot schedule new futures after shutdown")
-            if _global_shutdown:
-                raise RuntimeError(
-                    "cannot schedule new futures after " "interpreter shutdown"
-                )
-
-            f = _base.Future()
-            w = _WorkItem(f, fn, args, kwargs)
-
-            self._pending_work_items[self._queue_count] = w
-            self._work_ids.put(self._queue_count)
-            self._queue_count += 1
-            # Wake up queue management thread
-            self._queue_management_thread_wakeup.wakeup()
-
-            self._start_queue_management_thread()
-            return f
-
-    submit.__doc__ = _base.Executor.submit.__doc__
-
-    def map(self, fn, *iterables, timeout=None, chunksize=1):
-        """Returns an iterator equivalent to map(fn, iter).
-
-        Args:
-            fn: A callable that will take as many arguments as there are
-                passed iterables.
-            timeout: The maximum number of seconds to wait. If None, then there
-                is no limit on the wait time.
-            chunksize: If greater than one, the iterables will be chopped into
-                chunks of size chunksize and submitted to the process pool.
-                If set to one, the items in the list will be sent one at a time.
-
-        Returns:
-            An iterator equivalent to: map(func, *iterables) but the calls may
-            be evaluated out-of-order.
-
-        Raises:
-            TimeoutError: If the entire result iterator could not be generated
-                before the given timeout.
-            Exception: If fn(*args) raises for any values.
-        """
-        if chunksize < 1:
-            raise ValueError("chunksize must be >= 1.")
-
-        results = super().map(
-            partial(_process_chunk, fn),
-            _get_chunks(*iterables, chunksize=chunksize),
-            timeout=timeout,
-        )
-        return _chain_from_iterable_of_lists(results)
-
-    def shutdown(self, wait=True):
-        with self._shutdown_lock:
-            self._shutdown_thread = True
-        if self._queue_management_thread:
-            # Wake up queue management thread
-            self._queue_management_thread_wakeup.wakeup()
-            if wait:
-                self._queue_management_thread.join()
-        # To reduce the risk of opening too many files, remove references to
-        # objects that use file descriptors.
-        self._queue_management_thread = None
-        if self._call_queue is not None:
-            self._call_queue.close()
-            if wait:
-                self._call_queue.join_thread()
-            self._call_queue = None
-        self._result_queue = None
-        self._processes = None
-
-        if self._queue_management_thread_wakeup:
-            self._queue_management_thread_wakeup.close()
-            self._queue_management_thread_wakeup = None
-
-    shutdown.__doc__ = _base.Executor.shutdown.__doc__
-
-
-atexit.register(_python_exit)
diff --git a/addon/globalPlugins/spellcheck/libs/concurrent/futures/thread.py b/addon/globalPlugins/spellcheck/libs/concurrent/futures/thread.py
deleted file mode 100644
index d6346e9..0000000
--- a/addon/globalPlugins/spellcheck/libs/concurrent/futures/thread.py
+++ /dev/null
@@ -1,234 +0,0 @@
-# Copyright 2009 Brian Quinlan. All Rights Reserved.
-# Licensed to PSF under a Contributor Agreement.
-
-"""Implements ThreadPoolExecutor."""
-
-__author__ = "Brian Quinlan (brian@sweetapp.com)"
-
-import atexit
-from concurrent.futures import _base
-import itertools
-import queue
-import threading
-import weakref
-import os
-
-# Workers are created as daemon threads. This is done to allow the interpreter
-# to exit when there are still idle threads in a ThreadPoolExecutor's thread
-# pool (i.e. shutdown() was not called). However, allowing workers to die with
-# the interpreter has two undesirable properties:
-#   - The workers would still be running during interpreter shutdown,
-#     meaning that they would fail in unpredictable ways.
-#   - The workers could be killed while evaluating a work item, which could
-#     be bad if the callable being evaluated has external side-effects e.g.
-#     writing to a file.
-#
-# To work around this problem, an exit handler is installed which tells the
-# workers to exit when their work queues are empty and then waits until the
-# threads finish.
-
-_threads_queues = weakref.WeakKeyDictionary()
-_shutdown = False
-
-
-def _python_exit():
-    global _shutdown
-    _shutdown = True
-    items = list(_threads_queues.items())
-    for t, q in items:
-        q.put(None)
-    for t, q in items:
-        t.join()
-
-
-atexit.register(_python_exit)
-
-
-class _WorkItem(object):
-    def __init__(self, future, fn, args, kwargs):
-        self.future = future
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-
-    def run(self):
-        if not self.future.set_running_or_notify_cancel():
-            return
-
-        try:
-            result = self.fn(*self.args, **self.kwargs)
-        except BaseException as exc:
-            self.future.set_exception(exc)
-            # Break a reference cycle with the exception 'exc'
-            self = None
-        else:
-            self.future.set_result(result)
-
-
-def _worker(executor_reference, work_queue, initializer, initargs):
-    if initializer is not None:
-        try:
-            initializer(*initargs)
-        except BaseException:
-            _base.LOGGER.critical("Exception in initializer:", exc_info=True)
-            executor = executor_reference()
-            if executor is not None:
-                executor._initializer_failed()
-            return
-    try:
-        while True:
-            work_item = work_queue.get(block=True)
-            if work_item is not None:
-                work_item.run()
-                # Delete references to object. See issue16284
-                del work_item
-                continue
-            executor = executor_reference()
-            # Exit if:
-            #   - The interpreter is shutting down OR
-            #   - The executor that owns the worker has been collected OR
-            #   - The executor that owns the worker has been shutdown.
-            if _shutdown or executor is None or executor._shutdown:
-                # Flag the executor as shutting down as early as possible if it
-                # is not gc-ed yet.
-                if executor is not None:
-                    executor._shutdown = True
-                # Notice other workers
-                work_queue.put(None)
-                return
-            del executor
-    except BaseException:
-        _base.LOGGER.critical("Exception in worker", exc_info=True)
-
-
-class BrokenThreadPool(_base.BrokenExecutor):
-    """
-    Raised when a worker thread in a ThreadPoolExecutor failed initializing.
-    """
-
-
-class ThreadPoolExecutor(_base.Executor):
-
-    # Used to assign unique thread names when thread_name_prefix is not supplied.
-    _counter = itertools.count().__next__
-
-    def __init__(
-        self, max_workers=None, thread_name_prefix="", initializer=None, initargs=()
-    ):
-        """Initializes a new ThreadPoolExecutor instance.
-
-        Args:
-            max_workers: The maximum number of threads that can be used to
-                execute the given calls.
-            thread_name_prefix: An optional name prefix to give our threads.
-            initializer: A callable used to initialize worker threads.
-            initargs: A tuple of arguments to pass to the initializer.
-        """
-        if max_workers is None:
-            # Use this number because ThreadPoolExecutor is often
-            # used to overlap I/O instead of CPU work.
-            max_workers = (os.cpu_count() or 1) * 5
-        if max_workers <= 0:
-            raise ValueError("max_workers must be greater than 0")
-
-        if initializer is not None and not callable(initializer):
-            raise TypeError("initializer must be a callable")
-
-        self._max_workers = max_workers
-        self._work_queue = queue.SimpleQueue()
-        self._threads = set()
-        self._broken = False
-        self._shutdown = False
-        self._shutdown_lock = threading.Lock()
-        self._thread_name_prefix = thread_name_prefix or (
-            "ThreadPoolExecutor-%d" % self._counter()
-        )
-        self._initializer = initializer
-        self._initargs = initargs
-
-    def submit(*args, **kwargs):
-        if len(args) >= 2:
-            self, fn, *args = args
-        elif not args:
-            raise TypeError(
-                "descriptor 'submit' of 'ThreadPoolExecutor' object "
-                "needs an argument"
-            )
-        elif "fn" in kwargs:
-            fn = kwargs.pop("fn")
-            self, *args = args
-        else:
-            raise TypeError(
-                "submit expected at least 1 positional argument, "
-                "got %d" % (len(args) - 1)
-            )
-
-        with self._shutdown_lock:
-            if self._broken:
-                raise BrokenThreadPool(self._broken)
-
-            if self._shutdown:
-                raise RuntimeError("cannot schedule new futures after shutdown")
-            if _shutdown:
-                raise RuntimeError(
-                    "cannot schedule new futures after " "interpreter shutdown"
-                )
-
-            f = _base.Future()
-            w = _WorkItem(f, fn, args, kwargs)
-
-            self._work_queue.put(w)
-            self._adjust_thread_count()
-            return f
-
-    submit.__doc__ = _base.Executor.submit.__doc__
-
-    def _adjust_thread_count(self):
-        # When the executor gets lost, the weakref callback will wake up
-        # the worker threads.
-        def weakref_cb(_, q=self._work_queue):
-            q.put(None)
-
-        # TODO(bquinlan): Should avoid creating new threads if there are more
-        # idle threads than items in the work queue.
-        num_threads = len(self._threads)
-        if num_threads < self._max_workers:
-            thread_name = "%s_%d" % (self._thread_name_prefix or self, num_threads)
-            t = threading.Thread(
-                name=thread_name,
-                target=_worker,
-                args=(
-                    weakref.ref(self, weakref_cb),
-                    self._work_queue,
-                    self._initializer,
-                    self._initargs,
-                ),
-            )
-            t.daemon = True
-            t.start()
-            self._threads.add(t)
-            _threads_queues[t] = self._work_queue
-
-    def _initializer_failed(self):
-        with self._shutdown_lock:
-            self._broken = (
-                "A thread initializer failed, the thread pool " "is not usable anymore"
-            )
-            # Drain work queue and mark pending futures failed
-            while True:
-                try:
-                    work_item = self._work_queue.get_nowait()
-                except queue.Empty:
-                    break
-                if work_item is not None:
-                    work_item.future.set_exception(BrokenThreadPool(self._broken))
-
-    def shutdown(self, wait=True):
-        with self._shutdown_lock:
-            self._shutdown = True
-            self._work_queue.put(None)
-        if wait:
-            for t in self._threads:
-                t.join()
-
-    shutdown.__doc__ = _base.Executor.shutdown.__doc__
diff --git a/addon/globalPlugins/spellcheck/libs/enchant/_enchant.py b/addon/globalPlugins/spellcheck/libs/enchant/_enchant.py
index 7f7f7c8..b861057 100644
--- a/addon/globalPlugins/spellcheck/libs/enchant/_enchant.py
+++ b/addon/globalPlugins/spellcheck/libs/enchant/_enchant.py
@@ -52,9 +52,15 @@
 import sys
 import os
 import os.path
+dirAddon=os.path.dirname(__file__)
+sys.path.append(dirAddon)
+sys.path.append(os.path.join(dirAddon, "../_311"))
 import ctypes
+ctypes.__path__.append(os.path.join(dirAddon, "../_311", "ctypes"))
+
 from ctypes import c_char_p, c_int, c_size_t, c_void_p, pointer, CFUNCTYPE, POINTER
 import ctypes.util
+del sys.path[-1:]
 import platform
 import textwrap
 
diff --git a/addon/globalPlugins/spellcheck/libs/h11/__init__.py b/addon/globalPlugins/spellcheck/libs/h11/__init__.py
index ae39e01..989e92c 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/__init__.py
@@ -6,16 +6,57 @@
 # semantics to check that what you're asking to write to the wire is sensible,
 # but at least it gets you out of dealing with the wire itself.
 
-from ._connection import *
-from ._events import *
-from ._state import *
-from ._util import LocalProtocolError, ProtocolError, RemoteProtocolError
-from ._version import __version__
+from h11._connection import Connection, NEED_DATA, PAUSED
+from h11._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from h11._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    ERROR,
+    IDLE,
+    MIGHT_SWITCH_PROTOCOL,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
+from h11._util import LocalProtocolError, ProtocolError, RemoteProtocolError
+from h11._version import __version__
 
 PRODUCT_ID = "python-h11/" + __version__
 
 
-__all__ = ["ProtocolError", "LocalProtocolError", "RemoteProtocolError"]
-__all__ += _events.__all__
-__all__ += _connection.__all__
-__all__ += _state.__all__
+__all__ = (
+    "Connection",
+    "NEED_DATA",
+    "PAUSED",
+    "ConnectionClosed",
+    "Data",
+    "EndOfMessage",
+    "Event",
+    "InformationalResponse",
+    "Request",
+    "Response",
+    "CLIENT",
+    "CLOSED",
+    "DONE",
+    "ERROR",
+    "IDLE",
+    "MUST_CLOSE",
+    "SEND_BODY",
+    "SEND_RESPONSE",
+    "SERVER",
+    "SWITCHED_PROTOCOL",
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+)
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_abnf.py b/addon/globalPlugins/spellcheck/libs/h11/_abnf.py
index e6d49e1..933587f 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_abnf.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_abnf.py
@@ -125,5 +125,8 @@
 chunk_header = (
     r"(?P<chunk_size>{chunk_size})"
     r"(?P<chunk_ext>{chunk_ext})?"
-    r"\r\n".format(**globals())
+    r"{OWS}\r\n".format(
+        **globals()
+    )  # Even though the specification does not allow for extra whitespaces,
+    # we are lenient with trailing whitespaces because some servers on the wild use it.
 )
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_connection.py b/addon/globalPlugins/spellcheck/libs/h11/_connection.py
index 6f796ef..d175270 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_connection.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_connection.py
@@ -1,28 +1,53 @@
 # This contains the main Connection class. Everything in h11 revolves around
 # this.
-
-from ._events import *  # Import all event types
+from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Type, Union
+
+from ._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
 from ._headers import get_comma_header, has_expect_100_continue, set_comma_header
-from ._readers import READERS
+from ._readers import READERS, ReadersType
 from ._receivebuffer import ReceiveBuffer
-from ._state import *  # Import all state sentinels
-from ._state import _SWITCH_CONNECT, _SWITCH_UPGRADE, ConnectionState
+from ._state import (
+    _SWITCH_CONNECT,
+    _SWITCH_UPGRADE,
+    CLIENT,
+    ConnectionState,
+    DONE,
+    ERROR,
+    MIGHT_SWITCH_PROTOCOL,
+    SEND_BODY,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
 from ._util import (  # Import the internal things we need
     LocalProtocolError,
-    make_sentinel,
     RemoteProtocolError,
+    Sentinel,
 )
-from ._writers import WRITERS
+from ._writers import WRITERS, WritersType
 
 # Everything in __all__ gets re-exported as part of the h11 public API.
 __all__ = ["Connection", "NEED_DATA", "PAUSED"]
 
-NEED_DATA = make_sentinel("NEED_DATA")
-PAUSED = make_sentinel("PAUSED")
+
+class NEED_DATA(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class PAUSED(Sentinel, metaclass=Sentinel):
+    pass
+
 
 # If we ever have this much buffered without it making a complete parseable
 # event, we error out. The only time we really buffer is when reading the
-# request/reponse line + headers together, so this is effectively the limit on
+# request/response line + headers together, so this is effectively the limit on
 # the size of that.
 #
 # Some precedents for defaults:
@@ -44,7 +69,7 @@
 # our rule is:
 # - If someone says Connection: close, we will close
 # - If someone uses HTTP/1.0, we will close.
-def _keep_alive(event):
+def _keep_alive(event: Union[Request, Response]) -> bool:
     connection = get_comma_header(event.headers, b"connection")
     if b"close" in connection:
         return False
@@ -53,7 +78,9 @@ def _keep_alive(event):
     return True
 
 
-def _body_framing(request_method, event):
+def _body_framing(
+    request_method: bytes, event: Union[Request, Response]
+) -> Tuple[str, Union[Tuple[()], Tuple[int]]]:
     # Called when we enter SEND_BODY to figure out framing information for
     # this body.
     #
@@ -126,13 +153,16 @@ class Connection:
     """
 
     def __init__(
-        self, our_role, max_incomplete_event_size=DEFAULT_MAX_INCOMPLETE_EVENT_SIZE
-    ):
+        self,
+        our_role: Type[Sentinel],
+        max_incomplete_event_size: int = DEFAULT_MAX_INCOMPLETE_EVENT_SIZE,
+    ) -> None:
         self._max_incomplete_event_size = max_incomplete_event_size
         # State and role tracking
         if our_role not in (CLIENT, SERVER):
             raise ValueError("expected CLIENT or SERVER, not {!r}".format(our_role))
         self.our_role = our_role
+        self.their_role: Type[Sentinel]
         if our_role is CLIENT:
             self.their_role = SERVER
         else:
@@ -155,14 +185,14 @@ def __init__(
         # These two are only used to interpret framing headers for figuring
         # out how to read/write response bodies. their_http_version is also
         # made available as a convenient public API.
-        self.their_http_version = None
-        self._request_method = None
+        self.their_http_version: Optional[bytes] = None
+        self._request_method: Optional[bytes] = None
         # This is pure flow-control and doesn't at all affect the set of legal
         # transitions, so no need to bother ConnectionState with it:
         self.client_is_waiting_for_100_continue = False
 
     @property
-    def states(self):
+    def states(self) -> Dict[Type[Sentinel], Type[Sentinel]]:
         """A dictionary like::
 
            {CLIENT: <client state>, SERVER: <server state>}
@@ -173,24 +203,24 @@ def states(self):
         return dict(self._cstate.states)
 
     @property
-    def our_state(self):
+    def our_state(self) -> Type[Sentinel]:
         """The current state of whichever role we are playing. See
         :ref:`state-machine` for details.
         """
         return self._cstate.states[self.our_role]
 
     @property
-    def their_state(self):
+    def their_state(self) -> Type[Sentinel]:
         """The current state of whichever role we are NOT playing. See
         :ref:`state-machine` for details.
         """
         return self._cstate.states[self.their_role]
 
     @property
-    def they_are_waiting_for_100_continue(self):
+    def they_are_waiting_for_100_continue(self) -> bool:
         return self.their_role is CLIENT and self.client_is_waiting_for_100_continue
 
-    def start_next_cycle(self):
+    def start_next_cycle(self) -> None:
         """Attempt to reset our connection state for a new request/response
         cycle.
 
@@ -210,12 +240,12 @@ def start_next_cycle(self):
         assert not self.client_is_waiting_for_100_continue
         self._respond_to_state_changes(old_states)
 
-    def _process_error(self, role):
+    def _process_error(self, role: Type[Sentinel]) -> None:
         old_states = dict(self._cstate.states)
         self._cstate.process_error(role)
         self._respond_to_state_changes(old_states)
 
-    def _server_switch_event(self, event):
+    def _server_switch_event(self, event: Event) -> Optional[Type[Sentinel]]:
         if type(event) is InformationalResponse and event.status_code == 101:
             return _SWITCH_UPGRADE
         if type(event) is Response:
@@ -227,7 +257,7 @@ def _server_switch_event(self, event):
         return None
 
     # All events go through here
-    def _process_event(self, role, event):
+    def _process_event(self, role: Type[Sentinel], event: Event) -> None:
         # First, pass the event through the state machine to make sure it
         # succeeds.
         old_states = dict(self._cstate.states)
@@ -243,16 +273,15 @@ def _process_event(self, role, event):
 
         # Then perform the updates triggered by it.
 
-        # self._request_method
         if type(event) is Request:
             self._request_method = event.method
 
-        # self.their_http_version
         if role is self.their_role and type(event) in (
             Request,
             Response,
             InformationalResponse,
         ):
+            event = cast(Union[Request, Response, InformationalResponse], event)
             self.their_http_version = event.http_version
 
         # Keep alive handling
@@ -261,7 +290,9 @@ def _process_event(self, role, event):
         # shows up on a 1xx InformationalResponse. I think the idea is that
         # this is not supposed to happen. In any case, if it does happen, we
         # ignore it.
-        if type(event) in (Request, Response) and not _keep_alive(event):
+        if type(event) in (Request, Response) and not _keep_alive(
+            cast(Union[Request, Response], event)
+        ):
             self._cstate.process_keep_alive_disabled()
 
         # 100-continue
@@ -274,22 +305,33 @@ def _process_event(self, role, event):
 
         self._respond_to_state_changes(old_states, event)
 
-    def _get_io_object(self, role, event, io_dict):
+    def _get_io_object(
+        self,
+        role: Type[Sentinel],
+        event: Optional[Event],
+        io_dict: Union[ReadersType, WritersType],
+    ) -> Optional[Callable[..., Any]]:
         # event may be None; it's only used when entering SEND_BODY
         state = self._cstate.states[role]
         if state is SEND_BODY:
             # Special case: the io_dict has a dict of reader/writer factories
             # that depend on the request/response framing.
-            framing_type, args = _body_framing(self._request_method, event)
-            return io_dict[SEND_BODY][framing_type](*args)
+            framing_type, args = _body_framing(
+                cast(bytes, self._request_method), cast(Union[Request, Response], event)
+            )
+            return io_dict[SEND_BODY][framing_type](*args)  # type: ignore[index]
         else:
             # General case: the io_dict just has the appropriate reader/writer
             # for this state
-            return io_dict.get((role, state))
+            return io_dict.get((role, state))  # type: ignore[return-value]
 
     # This must be called after any action that might have caused
     # self._cstate.states to change.
-    def _respond_to_state_changes(self, old_states, event=None):
+    def _respond_to_state_changes(
+        self,
+        old_states: Dict[Type[Sentinel], Type[Sentinel]],
+        event: Optional[Event] = None,
+    ) -> None:
         # Update reader/writer
         if self.our_state != old_states[self.our_role]:
             self._writer = self._get_io_object(self.our_role, event, WRITERS)
@@ -297,7 +339,7 @@ def _respond_to_state_changes(self, old_states, event=None):
             self._reader = self._get_io_object(self.their_role, event, READERS)
 
     @property
-    def trailing_data(self):
+    def trailing_data(self) -> Tuple[bytes, bool]:
         """Data that has been received, but not yet processed, represented as
         a tuple with two elements, where the first is a byte-string containing
         the unprocessed data itself, and the second is a bool that is True if
@@ -307,7 +349,7 @@ def trailing_data(self):
         """
         return (bytes(self._receive_buffer), self._receive_buffer_closed)
 
-    def receive_data(self, data):
+    def receive_data(self, data: bytes) -> None:
         """Add data to our internal receive buffer.
 
         This does not actually do any processing on the data, just stores
@@ -353,7 +395,9 @@ def receive_data(self, data):
         else:
             self._receive_buffer_closed = True
 
-    def _extract_next_receive_event(self):
+    def _extract_next_receive_event(
+        self,
+    ) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
         state = self.their_state
         # We don't pause immediately when they enter DONE, because even in
         # DONE state we can still process a ConnectionClosed() event. But
@@ -372,14 +416,14 @@ def _extract_next_receive_event(self):
                 # return that event, and then the state will change and we'll
                 # get called again to generate the actual ConnectionClosed().
                 if hasattr(self._reader, "read_eof"):
-                    event = self._reader.read_eof()
+                    event = self._reader.read_eof()  # type: ignore[attr-defined]
                 else:
                     event = ConnectionClosed()
         if event is None:
             event = NEED_DATA
-        return event
+        return event  # type: ignore[no-any-return]
 
-    def next_event(self):
+    def next_event(self) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
         """Parse the next event out of our receive buffer, update our internal
         state, and return it.
 
@@ -424,7 +468,7 @@ def next_event(self):
         try:
             event = self._extract_next_receive_event()
             if event not in [NEED_DATA, PAUSED]:
-                self._process_event(self.their_role, event)
+                self._process_event(self.their_role, cast(Event, event))
             if event is NEED_DATA:
                 if len(self._receive_buffer) > self._max_incomplete_event_size:
                     # 431 is "Request header fields too large" which is pretty
@@ -444,7 +488,7 @@ def next_event(self):
             else:
                 raise
 
-    def send(self, event):
+    def send(self, event: Event) -> Optional[bytes]:
         """Convert a high-level event into bytes that can be sent to the peer,
         while updating our internal state machine.
 
@@ -471,7 +515,7 @@ def send(self, event):
         else:
             return b"".join(data_list)
 
-    def send_with_data_passthrough(self, event):
+    def send_with_data_passthrough(self, event: Event) -> Optional[List[bytes]]:
         """Identical to :meth:`send`, except that in situations where
         :meth:`send` returns a single :term:`bytes-like object`, this instead
         returns a list of them -- and when sending a :class:`Data` event, this
@@ -483,7 +527,7 @@ def send_with_data_passthrough(self, event):
             raise LocalProtocolError("Can't send data when our state is ERROR")
         try:
             if type(event) is Response:
-                self._clean_up_response_headers_for_sending(event)
+                event = self._clean_up_response_headers_for_sending(event)
             # We want to call _process_event before calling the writer,
             # because if someone tries to do something invalid then this will
             # give a sensible error message, while our writers all just assume
@@ -497,14 +541,14 @@ def send_with_data_passthrough(self, event):
                 # In any situation where writer is None, process_event should
                 # have raised ProtocolError
                 assert writer is not None
-                data_list = []
+                data_list: List[bytes] = []
                 writer(event, data_list.append)
                 return data_list
         except:
             self._process_error(self.our_role)
             raise
 
-    def send_failed(self):
+    def send_failed(self) -> None:
         """Notify the state machine that we failed to send the data it gave
         us.
 
@@ -528,9 +572,8 @@ def send_failed(self):
     #
     # This function's *only* responsibility is making sure headers are set up
     # right -- everything downstream just looks at the headers. There are no
-    # side channels. It mutates the response event in-place (but not the
-    # response.headers list object).
-    def _clean_up_response_headers_for_sending(self, response):
+    # side channels.
+    def _clean_up_response_headers_for_sending(self, response: Response) -> Response:
         assert type(response) is Response
 
         headers = response.headers
@@ -543,7 +586,7 @@ def _clean_up_response_headers_for_sending(self, response):
         # we're allowed to leave out the framing headers -- see
         # https://tools.ietf.org/html/rfc7231#section-4.3.2 . But it's just as
         # easy to get them right.)
-        method_for_choosing_headers = self._request_method
+        method_for_choosing_headers = cast(bytes, self._request_method)
         if method_for_choosing_headers == b"HEAD":
             method_for_choosing_headers = b"GET"
         framing_type, _ = _body_framing(method_for_choosing_headers, response)
@@ -573,7 +616,7 @@ def _clean_up_response_headers_for_sending(self, response):
                 if self._request_method != b"HEAD":
                     need_close = True
             else:
-                headers = set_comma_header(headers, b"transfer-encoding", ["chunked"])
+                headers = set_comma_header(headers, b"transfer-encoding", [b"chunked"])
 
         if not self._cstate.keep_alive or need_close:
             # Make sure Connection: close is set
@@ -582,4 +625,9 @@ def _clean_up_response_headers_for_sending(self, response):
             connection.add(b"close")
             headers = set_comma_header(headers, b"connection", sorted(connection))
 
-        response.headers = headers
+        return Response(
+            headers=headers,
+            status_code=response.status_code,
+            http_version=response.http_version,
+            reason=response.reason,
+        )
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_events.py b/addon/globalPlugins/spellcheck/libs/h11/_events.py
index 1827930..075bf8a 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_events.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_events.py
@@ -6,13 +6,17 @@
 # Don't subclass these. Stuff will break.
 
 import re
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Any, cast, Dict, List, Tuple, Union
 
-from . import _headers
-from ._abnf import request_target
+from ._abnf import method, request_target
+from ._headers import Headers, normalize_and_validate
 from ._util import bytesify, LocalProtocolError, validate
 
 # Everything in __all__ gets re-exported as part of the h11 public API.
 __all__ = [
+    "Event",
     "Request",
     "InformationalResponse",
     "Response",
@@ -21,75 +25,20 @@
     "ConnectionClosed",
 ]
 
+method_re = re.compile(method.encode("ascii"))
 request_target_re = re.compile(request_target.encode("ascii"))
 
 
-class _EventBundle:
-    _fields = []
-    _defaults = {}
-
-    def __init__(self, **kwargs):
-        _parsed = kwargs.pop("_parsed", False)
-        allowed = set(self._fields)
-        for kwarg in kwargs:
-            if kwarg not in allowed:
-                raise TypeError(
-                    "unrecognized kwarg {} for {}".format(
-                        kwarg, self.__class__.__name__
-                    )
-                )
-        required = allowed.difference(self._defaults)
-        for field in required:
-            if field not in kwargs:
-                raise TypeError(
-                    "missing required kwarg {} for {}".format(
-                        field, self.__class__.__name__
-                    )
-                )
-        self.__dict__.update(self._defaults)
-        self.__dict__.update(kwargs)
-
-        # Special handling for some fields
-
-        if "headers" in self.__dict__:
-            self.headers = _headers.normalize_and_validate(
-                self.headers, _parsed=_parsed
-            )
-
-        if not _parsed:
-            for field in ["method", "target", "http_version", "reason"]:
-                if field in self.__dict__:
-                    self.__dict__[field] = bytesify(self.__dict__[field])
-
-            if "status_code" in self.__dict__:
-                if not isinstance(self.status_code, int):
-                    raise LocalProtocolError("status code must be integer")
-                # Because IntEnum objects are instances of int, but aren't
-                # duck-compatible (sigh), see gh-72.
-                self.status_code = int(self.status_code)
-
-        self._validate()
-
-    def _validate(self):
-        pass
-
-    def __repr__(self):
-        name = self.__class__.__name__
-        kwarg_strs = [
-            "{}={}".format(field, self.__dict__[field]) for field in self._fields
-        ]
-        kwarg_str = ", ".join(kwarg_strs)
-        return "{}({})".format(name, kwarg_str)
-
-    # Useful for tests
-    def __eq__(self, other):
-        return self.__class__ == other.__class__ and self.__dict__ == other.__dict__
+class Event(ABC):
+    """
+    Base class for h11 events.
+    """
 
-    # This is an unhashable type.
-    __hash__ = None
+    __slots__ = ()
 
 
-class Request(_EventBundle):
+@dataclass(init=False, frozen=True)
+class Request(Event):
     """The beginning of an HTTP request.
 
     Fields:
@@ -123,10 +72,38 @@ class Request(_EventBundle):
 
     """
 
-    _fields = ["method", "target", "headers", "http_version"]
-    _defaults = {"http_version": b"1.1"}
+    __slots__ = ("method", "headers", "target", "http_version")
+
+    method: bytes
+    headers: Headers
+    target: bytes
+    http_version: bytes
+
+    def __init__(
+        self,
+        *,
+        method: Union[bytes, str],
+        headers: Union[Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]]],
+        target: Union[bytes, str],
+        http_version: Union[bytes, str] = b"1.1",
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if isinstance(headers, Headers):
+            object.__setattr__(self, "headers", headers)
+        else:
+            object.__setattr__(
+                self, "headers", normalize_and_validate(headers, _parsed=_parsed)
+            )
+        if not _parsed:
+            object.__setattr__(self, "method", bytesify(method))
+            object.__setattr__(self, "target", bytesify(target))
+            object.__setattr__(self, "http_version", bytesify(http_version))
+        else:
+            object.__setattr__(self, "method", method)
+            object.__setattr__(self, "target", target)
+            object.__setattr__(self, "http_version", http_version)
 
-    def _validate(self):
         # "A server MUST respond with a 400 (Bad Request) status code to any
         # HTTP/1.1 request message that lacks a Host header field and to any
         # request message that contains more than one Host header field or a
@@ -141,14 +118,61 @@ def _validate(self):
         if host_count > 1:
             raise LocalProtocolError("Found multiple Host: headers")
 
+        validate(method_re, self.method, "Illegal method characters")
         validate(request_target_re, self.target, "Illegal target characters")
 
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(init=False, frozen=True)
+class _ResponseBase(Event):
+    __slots__ = ("headers", "http_version", "reason", "status_code")
+
+    headers: Headers
+    http_version: bytes
+    reason: bytes
+    status_code: int
+
+    def __init__(
+        self,
+        *,
+        headers: Union[Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]]],
+        status_code: int,
+        http_version: Union[bytes, str] = b"1.1",
+        reason: Union[bytes, str] = b"",
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if isinstance(headers, Headers):
+            object.__setattr__(self, "headers", headers)
+        else:
+            object.__setattr__(
+                self, "headers", normalize_and_validate(headers, _parsed=_parsed)
+            )
+        if not _parsed:
+            object.__setattr__(self, "reason", bytesify(reason))
+            object.__setattr__(self, "http_version", bytesify(http_version))
+            if not isinstance(status_code, int):
+                raise LocalProtocolError("status code must be integer")
+            # Because IntEnum objects are instances of int, but aren't
+            # duck-compatible (sigh), see gh-72.
+            object.__setattr__(self, "status_code", int(status_code))
+        else:
+            object.__setattr__(self, "reason", reason)
+            object.__setattr__(self, "http_version", http_version)
+            object.__setattr__(self, "status_code", status_code)
+
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        pass
 
-class _ResponseBase(_EventBundle):
-    _fields = ["status_code", "headers", "http_version", "reason"]
-    _defaults = {"http_version": b"1.1", "reason": b""}
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
 
 
+@dataclass(init=False, frozen=True)
 class InformationalResponse(_ResponseBase):
     """An HTTP informational response.
 
@@ -179,14 +203,18 @@ class InformationalResponse(_ResponseBase):
 
     """
 
-    def _validate(self):
+    def __post_init__(self) -> None:
         if not (100 <= self.status_code < 200):
             raise LocalProtocolError(
                 "InformationalResponse status_code should be in range "
                 "[100, 200), not {}".format(self.status_code)
             )
 
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
 
+@dataclass(init=False, frozen=True)
 class Response(_ResponseBase):
     """The beginning of an HTTP response.
 
@@ -196,7 +224,7 @@ class Response(_ResponseBase):
 
        The status code of this response, as an integer. For an
        :class:`Response`, this is always in the range [200,
-       600).
+       1000).
 
     .. attribute:: headers
 
@@ -216,16 +244,20 @@ class Response(_ResponseBase):
 
     """
 
-    def _validate(self):
-        if not (200 <= self.status_code < 600):
+    def __post_init__(self) -> None:
+        if not (200 <= self.status_code < 1000):
             raise LocalProtocolError(
-                "Response status_code should be in range [200, 600), not {}".format(
+                "Response status_code should be in range [200, 1000), not {}".format(
                     self.status_code
                 )
             )
 
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
 
-class Data(_EventBundle):
+@dataclass(init=False, frozen=True)
+class Data(Event):
     """Part of an HTTP message body.
 
     Fields:
@@ -258,8 +290,21 @@ class Data(_EventBundle):
 
     """
 
-    _fields = ["data", "chunk_start", "chunk_end"]
-    _defaults = {"chunk_start": False, "chunk_end": False}
+    __slots__ = ("data", "chunk_start", "chunk_end")
+
+    data: bytes
+    chunk_start: bool
+    chunk_end: bool
+
+    def __init__(
+        self, data: bytes, chunk_start: bool = False, chunk_end: bool = False
+    ) -> None:
+        object.__setattr__(self, "data", data)
+        object.__setattr__(self, "chunk_start", chunk_start)
+        object.__setattr__(self, "chunk_end", chunk_end)
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
 
 
 # XX FIXME: "A recipient MUST ignore (or consider as an error) any fields that
@@ -267,7 +312,8 @@ class Data(_EventBundle):
 # present in the header section might bypass external security filters."
 # https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#chunked.trailer.part
 # Unfortunately, the list of forbidden fields is long and vague :-/
-class EndOfMessage(_EventBundle):
+@dataclass(init=False, frozen=True)
+class EndOfMessage(Event):
     """The end of an HTTP message.
 
     Fields:
@@ -284,11 +330,32 @@ class EndOfMessage(_EventBundle):
 
     """
 
-    _fields = ["headers"]
-    _defaults = {"headers": []}
+    __slots__ = ("headers",)
+
+    headers: Headers
+
+    def __init__(
+        self,
+        *,
+        headers: Union[
+            Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]], None
+        ] = None,
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if headers is None:
+            headers = Headers([])
+        elif not isinstance(headers, Headers):
+            headers = normalize_and_validate(headers, _parsed=_parsed)
+
+        object.__setattr__(self, "headers", headers)
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
 
 
-class ConnectionClosed(_EventBundle):
+@dataclass(frozen=True)
+class ConnectionClosed(Event):
     """This event indicates that the sender has closed their outgoing
     connection.
 
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_headers.py b/addon/globalPlugins/spellcheck/libs/h11/_headers.py
index 7ed39bc..b97d020 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_headers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_headers.py
@@ -1,8 +1,18 @@
 import re
+from typing import AnyStr, cast, List, overload, Sequence, Tuple, TYPE_CHECKING, Union
 
 from ._abnf import field_name, field_value
 from ._util import bytesify, LocalProtocolError, validate
 
+if TYPE_CHECKING:
+    from ._events import Request
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal  # type: ignore
+
+
 # Facts
 # -----
 #
@@ -57,12 +67,12 @@
 #
 # Maybe a dict-of-lists would be better?
 
-_content_length_re = re.compile(br"[0-9]+")
+_content_length_re = re.compile(rb"[0-9]+")
 _field_name_re = re.compile(field_name.encode("ascii"))
 _field_value_re = re.compile(field_value.encode("ascii"))
 
 
-class Headers:
+class Headers(Sequence[Tuple[bytes, bytes]]):
     """
     A list-like interface that allows iterating over headers as byte-pairs
     of (lowercased-name, value).
@@ -89,34 +99,57 @@ class Headers:
 
     __slots__ = "_full_items"
 
-    def __init__(self, full_items):
+    def __init__(self, full_items: List[Tuple[bytes, bytes, bytes]]) -> None:
         self._full_items = full_items
 
-    def __iter__(self):
-        for _, name, value in self._full_items:
-            yield name, value
-
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(self._full_items)
 
-    def __eq__(self, other):
-        return list(self) == list(other)
+    def __eq__(self, other: object) -> bool:
+        return list(self) == list(other)  # type: ignore
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._full_items)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<Headers(%s)>" % repr(list(self))
 
-    def __getitem__(self, idx):
+    def __getitem__(self, idx: int) -> Tuple[bytes, bytes]:  # type: ignore[override]
         _, name, value = self._full_items[idx]
         return (name, value)
 
-    def raw_items(self):
+    def raw_items(self) -> List[Tuple[bytes, bytes]]:
         return [(raw_name, value) for raw_name, _, value in self._full_items]
 
 
-def normalize_and_validate(headers, _parsed=False):
+HeaderTypes = Union[
+    List[Tuple[bytes, bytes]],
+    List[Tuple[bytes, str]],
+    List[Tuple[str, bytes]],
+    List[Tuple[str, str]],
+]
+
+
+@overload
+def normalize_and_validate(headers: Headers, _parsed: Literal[True]) -> Headers:
+    ...
+
+
+@overload
+def normalize_and_validate(headers: HeaderTypes, _parsed: Literal[False]) -> Headers:
+    ...
+
+
+@overload
+def normalize_and_validate(
+    headers: Union[Headers, HeaderTypes], _parsed: bool = False
+) -> Headers:
+    ...
+
+
+def normalize_and_validate(
+    headers: Union[Headers, HeaderTypes], _parsed: bool = False
+) -> Headers:
     new_headers = []
     seen_content_length = None
     saw_transfer_encoding = False
@@ -129,6 +162,9 @@ def normalize_and_validate(headers, _parsed=False):
             value = bytesify(value)
             validate(_field_name_re, name, "Illegal header name {!r}", name)
             validate(_field_value_re, value, "Illegal header value {!r}", value)
+        assert isinstance(name, bytes)
+        assert isinstance(value, bytes)
+
         raw_name = name
         name = name.lower()
         if name == b"content-length":
@@ -166,7 +202,7 @@ def normalize_and_validate(headers, _parsed=False):
     return Headers(new_headers)
 
 
-def get_comma_header(headers, name):
+def get_comma_header(headers: Headers, name: bytes) -> List[bytes]:
     # Should only be used for headers whose value is a list of
     # comma-separated, case-insensitive values.
     #
@@ -202,7 +238,7 @@ def get_comma_header(headers, name):
     # Expect: the only legal value is the literal string
     # "100-continue". Splitting on commas is harmless. Case insensitive.
     #
-    out = []
+    out: List[bytes] = []
     for _, found_name, found_raw_value in headers._full_items:
         if found_name == name:
             found_raw_value = found_raw_value.lower()
@@ -213,7 +249,7 @@ def get_comma_header(headers, name):
     return out
 
 
-def set_comma_header(headers, name, new_values):
+def set_comma_header(headers: Headers, name: bytes, new_values: List[bytes]) -> Headers:
     # The header name `name` is expected to be lower-case bytes.
     #
     # Note that when we store the header we use title casing for the header
@@ -223,7 +259,7 @@ def set_comma_header(headers, name, new_values):
     # here given the cases where we're using `set_comma_header`...
     #
     # Connection, Content-Length, Transfer-Encoding.
-    new_headers = []
+    new_headers: List[Tuple[bytes, bytes]] = []
     for found_raw_name, found_name, found_raw_value in headers._full_items:
         if found_name != name:
             new_headers.append((found_raw_name, found_raw_value))
@@ -232,7 +268,7 @@ def set_comma_header(headers, name, new_values):
     return normalize_and_validate(new_headers)
 
 
-def has_expect_100_continue(request):
+def has_expect_100_continue(request: "Request") -> bool:
     # https://tools.ietf.org/html/rfc7231#section-5.1.1
     # "A server that receives a 100-continue expectation in an HTTP/1.0 request
     # MUST ignore that expectation."
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_readers.py b/addon/globalPlugins/spellcheck/libs/h11/_readers.py
index 0ead0be..08a9574 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_readers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_readers.py
@@ -17,30 +17,39 @@
 # - or, for body readers, a dict of per-framing reader factories
 
 import re
+from typing import Any, Callable, Dict, Iterable, NoReturn, Optional, Tuple, Type, Union
 
 from ._abnf import chunk_header, header_field, request_line, status_line
-from ._events import *
-from ._state import *
-from ._util import LocalProtocolError, RemoteProtocolError, validate
+from ._events import Data, EndOfMessage, InformationalResponse, Request, Response
+from ._receivebuffer import ReceiveBuffer
+from ._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    IDLE,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+)
+from ._util import LocalProtocolError, RemoteProtocolError, Sentinel, validate
 
 __all__ = ["READERS"]
 
 header_field_re = re.compile(header_field.encode("ascii"))
+obs_fold_re = re.compile(rb"[ \t]+")
 
-# Remember that this has to run in O(n) time -- so e.g. the bytearray cast is
-# critical.
-obs_fold_re = re.compile(br"[ \t]+")
 
-
-def _obsolete_line_fold(lines):
+def _obsolete_line_fold(lines: Iterable[bytes]) -> Iterable[bytes]:
     it = iter(lines)
-    last = None
+    last: Optional[bytes] = None
     for line in it:
         match = obs_fold_re.match(line)
         if match:
             if last is None:
                 raise LocalProtocolError("continuation line at start of headers")
             if not isinstance(last, bytearray):
+                # Cast to a mutable type, avoiding copy on append to ensure O(n) time
                 last = bytearray(last)
             last += b" "
             last += line[match.end() :]
@@ -52,7 +61,9 @@ def _obsolete_line_fold(lines):
         yield last
 
 
-def _decode_header_lines(lines):
+def _decode_header_lines(
+    lines: Iterable[bytes],
+) -> Iterable[Tuple[bytes, bytes]]:
     for line in _obsolete_line_fold(lines):
         matches = validate(header_field_re, line, "illegal header line: {!r}", line)
         yield (matches["field_name"], matches["field_value"])
@@ -61,7 +72,7 @@ def _decode_header_lines(lines):
 request_line_re = re.compile(request_line.encode("ascii"))
 
 
-def maybe_read_from_IDLE_client(buf):
+def maybe_read_from_IDLE_client(buf: ReceiveBuffer) -> Optional[Request]:
     lines = buf.maybe_extract_lines()
     if lines is None:
         if buf.is_next_line_obviously_invalid_request_line():
@@ -80,7 +91,9 @@ def maybe_read_from_IDLE_client(buf):
 status_line_re = re.compile(status_line.encode("ascii"))
 
 
-def maybe_read_from_SEND_RESPONSE_server(buf):
+def maybe_read_from_SEND_RESPONSE_server(
+    buf: ReceiveBuffer,
+) -> Union[InformationalResponse, Response, None]:
     lines = buf.maybe_extract_lines()
     if lines is None:
         if buf.is_next_line_obviously_invalid_request_line():
@@ -89,22 +102,29 @@ def maybe_read_from_SEND_RESPONSE_server(buf):
     if not lines:
         raise LocalProtocolError("no response line received")
     matches = validate(status_line_re, lines[0], "illegal status line: {!r}", lines[0])
-    # Tolerate missing reason phrases
-    if matches["reason"] is None:
-        matches["reason"] = b""
-    status_code = matches["status_code"] = int(matches["status_code"])
-    class_ = InformationalResponse if status_code < 200 else Response
+    http_version = (
+        b"1.1" if matches["http_version"] is None else matches["http_version"]
+    )
+    reason = b"" if matches["reason"] is None else matches["reason"]
+    status_code = int(matches["status_code"])
+    class_: Union[Type[InformationalResponse], Type[Response]] = (
+        InformationalResponse if status_code < 200 else Response
+    )
     return class_(
-        headers=list(_decode_header_lines(lines[1:])), _parsed=True, **matches
+        headers=list(_decode_header_lines(lines[1:])),
+        _parsed=True,
+        status_code=status_code,
+        reason=reason,
+        http_version=http_version,
     )
 
 
 class ContentLengthReader:
-    def __init__(self, length):
+    def __init__(self, length: int) -> None:
         self._length = length
         self._remaining = length
 
-    def __call__(self, buf):
+    def __call__(self, buf: ReceiveBuffer) -> Union[Data, EndOfMessage, None]:
         if self._remaining == 0:
             return EndOfMessage()
         data = buf.maybe_extract_at_most(self._remaining)
@@ -113,7 +133,7 @@ def __call__(self, buf):
         self._remaining -= len(data)
         return Data(data=data)
 
-    def read_eof(self):
+    def read_eof(self) -> NoReturn:
         raise RemoteProtocolError(
             "peer closed connection without sending complete message body "
             "(received {} bytes, expected {})".format(
@@ -126,7 +146,7 @@ def read_eof(self):
 
 
 class ChunkedReader:
-    def __init__(self):
+    def __init__(self) -> None:
         self._bytes_in_chunk = 0
         # After reading a chunk, we have to throw away the trailing \r\n; if
         # this is >0 then we discard that many bytes before resuming regular
@@ -134,7 +154,7 @@ def __init__(self):
         self._bytes_to_discard = 0
         self._reading_trailer = False
 
-    def __call__(self, buf):
+    def __call__(self, buf: ReceiveBuffer) -> Union[Data, EndOfMessage, None]:
         if self._reading_trailer:
             lines = buf.maybe_extract_lines()
             if lines is None:
@@ -180,7 +200,7 @@ def __call__(self, buf):
             chunk_end = False
         return Data(data=data, chunk_start=chunk_start, chunk_end=chunk_end)
 
-    def read_eof(self):
+    def read_eof(self) -> NoReturn:
         raise RemoteProtocolError(
             "peer closed connection without sending complete message body "
             "(incomplete chunked read)"
@@ -188,23 +208,28 @@ def read_eof(self):
 
 
 class Http10Reader:
-    def __call__(self, buf):
+    def __call__(self, buf: ReceiveBuffer) -> Optional[Data]:
         data = buf.maybe_extract_at_most(999999999)
         if data is None:
             return None
         return Data(data=data)
 
-    def read_eof(self):
+    def read_eof(self) -> EndOfMessage:
         return EndOfMessage()
 
 
-def expect_nothing(buf):
+def expect_nothing(buf: ReceiveBuffer) -> None:
     if buf:
         raise LocalProtocolError("Got data when expecting EOF")
     return None
 
 
-READERS = {
+ReadersType = Dict[
+    Union[Type[Sentinel], Tuple[Type[Sentinel], Type[Sentinel]]],
+    Union[Callable[..., Any], Dict[str, Callable[..., Any]]],
+]
+
+READERS: ReadersType = {
     (CLIENT, IDLE): maybe_read_from_IDLE_client,
     (SERVER, IDLE): maybe_read_from_SEND_RESPONSE_server,
     (SERVER, SEND_RESPONSE): maybe_read_from_SEND_RESPONSE_server,
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_receivebuffer.py b/addon/globalPlugins/spellcheck/libs/h11/_receivebuffer.py
index a3737f3..e5c4e08 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_receivebuffer.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_receivebuffer.py
@@ -1,5 +1,6 @@
 import re
 import sys
+from typing import List, Optional, Union
 
 __all__ = ["ReceiveBuffer"]
 
@@ -44,26 +45,26 @@
 
 
 class ReceiveBuffer:
-    def __init__(self):
+    def __init__(self) -> None:
         self._data = bytearray()
         self._next_line_search = 0
         self._multiple_lines_search = 0
 
-    def __iadd__(self, byteslike):
+    def __iadd__(self, byteslike: Union[bytes, bytearray]) -> "ReceiveBuffer":
         self._data += byteslike
         return self
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(len(self))
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._data)
 
     # for @property unprocessed_data
-    def __bytes__(self):
+    def __bytes__(self) -> bytes:
         return bytes(self._data)
 
-    def _extract(self, count):
+    def _extract(self, count: int) -> bytearray:
         # extracting an initial slice of the data buffer and return it
         out = self._data[:count]
         del self._data[:count]
@@ -73,7 +74,7 @@ def _extract(self, count):
 
         return out
 
-    def maybe_extract_at_most(self, count):
+    def maybe_extract_at_most(self, count: int) -> Optional[bytearray]:
         """
         Extract a fixed number of bytes from the buffer.
         """
@@ -83,7 +84,7 @@ def maybe_extract_at_most(self, count):
 
         return self._extract(count)
 
-    def maybe_extract_next_line(self):
+    def maybe_extract_next_line(self) -> Optional[bytearray]:
         """
         Extract the first line, if it is completed in the buffer.
         """
@@ -100,7 +101,7 @@ def maybe_extract_next_line(self):
 
         return self._extract(idx)
 
-    def maybe_extract_lines(self):
+    def maybe_extract_lines(self) -> Optional[List[bytearray]]:
         """
         Extract everything up to the first blank line, and return a list of lines.
         """
@@ -143,7 +144,7 @@ def maybe_extract_lines(self):
     # This is especially interesting when peer is messing up with HTTPS and
     # sent us a TLS stream where we were expecting plain HTTP given all
     # versions of TLS so far start handshake with a 0x16 message type code.
-    def is_next_line_obviously_invalid_request_line(self):
+    def is_next_line_obviously_invalid_request_line(self) -> bool:
         try:
             # HTTP header line must not contain non-printable characters
             # and should not start with a space
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_state.py b/addon/globalPlugins/spellcheck/libs/h11/_state.py
index 0f08a09..3593430 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_state.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_state.py
@@ -110,9 +110,10 @@
 # tables. But it can't automatically read the transitions that are written
 # directly in Python code. So if you touch those, you need to also update the
 # script to keep it in sync!
+from typing import cast, Dict, Optional, Set, Tuple, Type, Union
 
 from ._events import *
-from ._util import LocalProtocolError, make_sentinel
+from ._util import LocalProtocolError, Sentinel
 
 # Everything in __all__ gets re-exported as part of the h11 public API.
 __all__ = [
@@ -129,26 +130,70 @@
     "ERROR",
 ]
 
-CLIENT = make_sentinel("CLIENT")
-SERVER = make_sentinel("SERVER")
+
+class CLIENT(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SERVER(Sentinel, metaclass=Sentinel):
+    pass
+
 
 # States
-IDLE = make_sentinel("IDLE")
-SEND_RESPONSE = make_sentinel("SEND_RESPONSE")
-SEND_BODY = make_sentinel("SEND_BODY")
-DONE = make_sentinel("DONE")
-MUST_CLOSE = make_sentinel("MUST_CLOSE")
-CLOSED = make_sentinel("CLOSED")
-ERROR = make_sentinel("ERROR")
+class IDLE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SEND_RESPONSE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SEND_BODY(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class DONE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class MUST_CLOSE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class CLOSED(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class ERROR(Sentinel, metaclass=Sentinel):
+    pass
+
 
 # Switch types
-MIGHT_SWITCH_PROTOCOL = make_sentinel("MIGHT_SWITCH_PROTOCOL")
-SWITCHED_PROTOCOL = make_sentinel("SWITCHED_PROTOCOL")
+class MIGHT_SWITCH_PROTOCOL(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SWITCHED_PROTOCOL(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class _SWITCH_UPGRADE(Sentinel, metaclass=Sentinel):
+    pass
+
 
-_SWITCH_UPGRADE = make_sentinel("_SWITCH_UPGRADE")
-_SWITCH_CONNECT = make_sentinel("_SWITCH_CONNECT")
+class _SWITCH_CONNECT(Sentinel, metaclass=Sentinel):
+    pass
 
-EVENT_TRIGGERED_TRANSITIONS = {
+
+EventTransitionType = Dict[
+    Type[Sentinel],
+    Dict[
+        Type[Sentinel],
+        Dict[Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]], Type[Sentinel]],
+    ],
+]
+
+EVENT_TRIGGERED_TRANSITIONS: EventTransitionType = {
     CLIENT: {
         IDLE: {Request: SEND_BODY, ConnectionClosed: CLOSED},
         SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
@@ -181,9 +226,13 @@
     },
 }
 
+StateTransitionType = Dict[
+    Tuple[Type[Sentinel], Type[Sentinel]], Dict[Type[Sentinel], Type[Sentinel]]
+]
+
 # NB: there are also some special-case state-triggered transitions hard-coded
 # into _fire_state_triggered_transitions below.
-STATE_TRIGGERED_TRANSITIONS = {
+STATE_TRIGGERED_TRANSITIONS: StateTransitionType = {
     # (Client state, Server state) -> new states
     # Protocol negotiation
     (MIGHT_SWITCH_PROTOCOL, SWITCHED_PROTOCOL): {CLIENT: SWITCHED_PROTOCOL},
@@ -198,7 +247,7 @@
 
 
 class ConnectionState:
-    def __init__(self):
+    def __init__(self) -> None:
         # Extra bits of state that don't quite fit into the state model.
 
         # If this is False then it enables the automatic DONE -> MUST_CLOSE
@@ -207,23 +256,29 @@ def __init__(self):
 
         # This is a subset of {UPGRADE, CONNECT}, containing the proposals
         # made by the client for switching protocols.
-        self.pending_switch_proposals = set()
+        self.pending_switch_proposals: Set[Type[Sentinel]] = set()
 
-        self.states = {CLIENT: IDLE, SERVER: IDLE}
+        self.states: Dict[Type[Sentinel], Type[Sentinel]] = {CLIENT: IDLE, SERVER: IDLE}
 
-    def process_error(self, role):
+    def process_error(self, role: Type[Sentinel]) -> None:
         self.states[role] = ERROR
         self._fire_state_triggered_transitions()
 
-    def process_keep_alive_disabled(self):
+    def process_keep_alive_disabled(self) -> None:
         self.keep_alive = False
         self._fire_state_triggered_transitions()
 
-    def process_client_switch_proposal(self, switch_event):
+    def process_client_switch_proposal(self, switch_event: Type[Sentinel]) -> None:
         self.pending_switch_proposals.add(switch_event)
         self._fire_state_triggered_transitions()
 
-    def process_event(self, role, event_type, server_switch_event=None):
+    def process_event(
+        self,
+        role: Type[Sentinel],
+        event_type: Type[Event],
+        server_switch_event: Optional[Type[Sentinel]] = None,
+    ) -> None:
+        _event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]] = event_type
         if server_switch_event is not None:
             assert role is SERVER
             if server_switch_event not in self.pending_switch_proposals:
@@ -232,30 +287,35 @@ def process_event(self, role, event_type, server_switch_event=None):
                         server_switch_event
                     )
                 )
-            event_type = (event_type, server_switch_event)
-        if server_switch_event is None and event_type is Response:
+            _event_type = (event_type, server_switch_event)
+        if server_switch_event is None and _event_type is Response:
             self.pending_switch_proposals = set()
-        self._fire_event_triggered_transitions(role, event_type)
+        self._fire_event_triggered_transitions(role, _event_type)
         # Special case: the server state does get to see Request
         # events.
-        if event_type is Request:
+        if _event_type is Request:
             assert role is CLIENT
             self._fire_event_triggered_transitions(SERVER, (Request, CLIENT))
         self._fire_state_triggered_transitions()
 
-    def _fire_event_triggered_transitions(self, role, event_type):
+    def _fire_event_triggered_transitions(
+        self,
+        role: Type[Sentinel],
+        event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]],
+    ) -> None:
         state = self.states[role]
         try:
             new_state = EVENT_TRIGGERED_TRANSITIONS[role][state][event_type]
         except KeyError:
+            event_type = cast(Type[Event], event_type)
             raise LocalProtocolError(
                 "can't handle event type {} when role={} and state={}".format(
                     event_type.__name__, role, self.states[role]
                 )
-            )
+            ) from None
         self.states[role] = new_state
 
-    def _fire_state_triggered_transitions(self):
+    def _fire_state_triggered_transitions(self) -> None:
         # We apply these rules repeatedly until converging on a fixed point
         while True:
             start_states = dict(self.states)
@@ -295,7 +355,7 @@ def _fire_state_triggered_transitions(self):
                 # Fixed point reached
                 return
 
-    def start_next_cycle(self):
+    def start_next_cycle(self) -> None:
         if self.states != {CLIENT: DONE, SERVER: DONE}:
             raise LocalProtocolError(
                 "not in a reusable state. self.states={}".format(self.states)
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_util.py b/addon/globalPlugins/spellcheck/libs/h11/_util.py
index eb1a5cd..6718445 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_util.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_util.py
@@ -1,9 +1,10 @@
+from typing import Any, Dict, NoReturn, Pattern, Tuple, Type, TypeVar, Union
+
 __all__ = [
     "ProtocolError",
     "LocalProtocolError",
     "RemoteProtocolError",
     "validate",
-    "make_sentinel",
     "bytesify",
 ]
 
@@ -37,7 +38,7 @@ class ProtocolError(Exception):
 
     """
 
-    def __init__(self, msg, error_status_hint=400):
+    def __init__(self, msg: str, error_status_hint: int = 400) -> None:
         if type(self) is ProtocolError:
             raise TypeError("tried to directly instantiate ProtocolError")
         Exception.__init__(self, msg)
@@ -56,14 +57,14 @@ def __init__(self, msg, error_status_hint=400):
 #   LocalProtocolError is for local errors and RemoteProtocolError is for
 #   remote errors.
 class LocalProtocolError(ProtocolError):
-    def _reraise_as_remote_protocol_error(self):
+    def _reraise_as_remote_protocol_error(self) -> NoReturn:
         # After catching a LocalProtocolError, use this method to re-raise it
         # as a RemoteProtocolError. This method must be called from inside an
         # except: block.
         #
         # An easy way to get an equivalent RemoteProtocolError is just to
         # modify 'self' in place.
-        self.__class__ = RemoteProtocolError
+        self.__class__ = RemoteProtocolError  # type: ignore
         # But the re-raising is somewhat non-trivial -- you might think that
         # now that we've modified the in-flight exception object, that just
         # doing 'raise' to re-raise it would be enough. But it turns out that
@@ -80,7 +81,9 @@ class RemoteProtocolError(ProtocolError):
     pass
 
 
-def validate(regex, data, msg="malformed data", *format_args):
+def validate(
+    regex: Pattern[bytes], data: bytes, msg: str = "malformed data", *format_args: Any
+) -> Dict[str, bytes]:
     match = regex.fullmatch(data)
     if not match:
         if format_args:
@@ -97,21 +100,31 @@ def validate(regex, data, msg="malformed data", *format_args):
 #
 # The bonus property is useful if you want to take the return value from
 # next_event() and do some sort of dispatch based on type(event).
-class _SentinelBase(type):
-    def __repr__(self):
-        return self.__name__
+
+_T_Sentinel = TypeVar("_T_Sentinel", bound="Sentinel")
 
 
-def make_sentinel(name):
-    cls = _SentinelBase(name, (_SentinelBase,), {})
-    cls.__class__ = cls
-    return cls
+class Sentinel(type):
+    def __new__(
+        cls: Type[_T_Sentinel],
+        name: str,
+        bases: Tuple[type, ...],
+        namespace: Dict[str, Any],
+        **kwds: Any
+    ) -> _T_Sentinel:
+        assert bases == (Sentinel,)
+        v = super().__new__(cls, name, bases, namespace, **kwds)
+        v.__class__ = v  # type: ignore
+        return v
+
+    def __repr__(self) -> str:
+        return self.__name__
 
 
 # Used for methods, request targets, HTTP versions, header names, and header
 # values. Accepts ascii-strings, or bytes/bytearray/memoryview/..., and always
 # returns bytes.
-def bytesify(s):
+def bytesify(s: Union[bytes, bytearray, memoryview, int, str]) -> bytes:
     # Fast-path:
     if type(s) is bytes:
         return s
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_version.py b/addon/globalPlugins/spellcheck/libs/h11/_version.py
index cb5c2c3..4c89113 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_version.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_version.py
@@ -13,4 +13,4 @@
 # want. (Contrast with the special suffix 1.0.0.dev, which sorts *before*
 # 1.0.0.)
 
-__version__ = "0.12.0"
+__version__ = "0.14.0"
diff --git a/addon/globalPlugins/spellcheck/libs/h11/_writers.py b/addon/globalPlugins/spellcheck/libs/h11/_writers.py
index cb5e8a8..939cdb9 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/_writers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/_writers.py
@@ -7,14 +7,19 @@
 # - a writer
 # - or, for body writers, a dict of framin-dependent writer factories
 
-from ._events import Data, EndOfMessage
+from typing import Any, Callable, Dict, List, Tuple, Type, Union
+
+from ._events import Data, EndOfMessage, Event, InformationalResponse, Request, Response
+from ._headers import Headers
 from ._state import CLIENT, IDLE, SEND_BODY, SEND_RESPONSE, SERVER
-from ._util import LocalProtocolError
+from ._util import LocalProtocolError, Sentinel
 
 __all__ = ["WRITERS"]
 
+Writer = Callable[[bytes], Any]
+
 
-def write_headers(headers, write):
+def write_headers(headers: Headers, write: Writer) -> None:
     # "Since the Host field-value is critical information for handling a
     # request, a user agent SHOULD generate Host as the first header field
     # following the request-line." - RFC 7230
@@ -28,7 +33,7 @@ def write_headers(headers, write):
     write(b"\r\n")
 
 
-def write_request(request, write):
+def write_request(request: Request, write: Writer) -> None:
     if request.http_version != b"1.1":
         raise LocalProtocolError("I only send HTTP/1.1")
     write(b"%s %s HTTP/1.1\r\n" % (request.method, request.target))
@@ -36,7 +41,9 @@ def write_request(request, write):
 
 
 # Shared between InformationalResponse and Response
-def write_any_response(response, write):
+def write_any_response(
+    response: Union[InformationalResponse, Response], write: Writer
+) -> None:
     if response.http_version != b"1.1":
         raise LocalProtocolError("I only send HTTP/1.1")
     status_bytes = str(response.status_code).encode("ascii")
@@ -53,7 +60,7 @@ def write_any_response(response, write):
 
 
 class BodyWriter:
-    def __call__(self, event, write):
+    def __call__(self, event: Event, write: Writer) -> None:
         if type(event) is Data:
             self.send_data(event.data, write)
         elif type(event) is EndOfMessage:
@@ -61,6 +68,12 @@ def __call__(self, event, write):
         else:  # pragma: no cover
             assert False
 
+    def send_data(self, data: bytes, write: Writer) -> None:
+        pass
+
+    def send_eom(self, headers: Headers, write: Writer) -> None:
+        pass
+
 
 #
 # These are all careful not to do anything to 'data' except call len(data) and
@@ -69,16 +82,16 @@ def __call__(self, event, write):
 # sendfile(2).
 #
 class ContentLengthWriter(BodyWriter):
-    def __init__(self, length):
+    def __init__(self, length: int) -> None:
         self._length = length
 
-    def send_data(self, data, write):
+    def send_data(self, data: bytes, write: Writer) -> None:
         self._length -= len(data)
         if self._length < 0:
             raise LocalProtocolError("Too much data for declared Content-Length")
         write(data)
 
-    def send_eom(self, headers, write):
+    def send_eom(self, headers: Headers, write: Writer) -> None:
         if self._length != 0:
             raise LocalProtocolError("Too little data for declared Content-Length")
         if headers:
@@ -86,7 +99,7 @@ def send_eom(self, headers, write):
 
 
 class ChunkedWriter(BodyWriter):
-    def send_data(self, data, write):
+    def send_data(self, data: bytes, write: Writer) -> None:
         # if we encoded 0-length data in the naive way, it would look like an
         # end-of-message.
         if not data:
@@ -95,23 +108,32 @@ def send_data(self, data, write):
         write(data)
         write(b"\r\n")
 
-    def send_eom(self, headers, write):
+    def send_eom(self, headers: Headers, write: Writer) -> None:
         write(b"0\r\n")
         write_headers(headers, write)
 
 
 class Http10Writer(BodyWriter):
-    def send_data(self, data, write):
+    def send_data(self, data: bytes, write: Writer) -> None:
         write(data)
 
-    def send_eom(self, headers, write):
+    def send_eom(self, headers: Headers, write: Writer) -> None:
         if headers:
             raise LocalProtocolError("can't send trailers to HTTP/1.0 client")
         # no need to close the socket ourselves, that will be taken care of by
         # Connection: close machinery
 
 
-WRITERS = {
+WritersType = Dict[
+    Union[Tuple[Type[Sentinel], Type[Sentinel]], Type[Sentinel]],
+    Union[
+        Dict[str, Type[BodyWriter]],
+        Callable[[Union[InformationalResponse, Response], Writer], None],
+        Callable[[Request, Writer], None],
+    ],
+]
+
+WRITERS: WritersType = {
     (CLIENT, IDLE): write_request,
     (SERVER, IDLE): write_any_response,
     (SERVER, SEND_RESPONSE): write_any_response,
diff --git a/addon/globalPlugins/spellcheck/libs/h11/py.typed b/addon/globalPlugins/spellcheck/libs/h11/py.typed
new file mode 100644
index 0000000..f5642f7
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/h11/py.typed
@@ -0,0 +1 @@
+Marker
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/helpers.py b/addon/globalPlugins/spellcheck/libs/h11/tests/helpers.py
index 9d2cf38..571be44 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/helpers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/helpers.py
@@ -1,36 +1,55 @@
-from .._connection import *
-from .._events import *
-from .._state import *
+from typing import cast, List, Type, Union, ValuesView
 
+from .._connection import Connection, NEED_DATA, PAUSED
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from .._state import CLIENT, CLOSED, DONE, MUST_CLOSE, SERVER
+from .._util import Sentinel
 
-def get_all_events(conn):
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal  # type: ignore
+
+
+def get_all_events(conn: Connection) -> List[Event]:
     got_events = []
     while True:
         event = conn.next_event()
         if event in (NEED_DATA, PAUSED):
             break
+        event = cast(Event, event)
         got_events.append(event)
         if type(event) is ConnectionClosed:
             break
     return got_events
 
 
-def receive_and_get(conn, data):
+def receive_and_get(conn: Connection, data: bytes) -> List[Event]:
     conn.receive_data(data)
     return get_all_events(conn)
 
 
 # Merges adjacent Data events, converts payloads to bytestrings, and removes
 # chunk boundaries.
-def normalize_data_events(in_events):
-    out_events = []
+def normalize_data_events(in_events: List[Event]) -> List[Event]:
+    out_events: List[Event] = []
     for event in in_events:
         if type(event) is Data:
-            event.data = bytes(event.data)
-            event.chunk_start = False
-            event.chunk_end = False
+            event = Data(data=bytes(event.data), chunk_start=False, chunk_end=False)
         if out_events and type(out_events[-1]) is type(event) is Data:
-            out_events[-1].data += event.data
+            out_events[-1] = Data(
+                data=out_events[-1].data + event.data,
+                chunk_start=out_events[-1].chunk_start,
+                chunk_end=out_events[-1].chunk_end,
+            )
         else:
             out_events.append(event)
     return out_events
@@ -41,16 +60,21 @@ def normalize_data_events(in_events):
 # of pushing them through two Connections with a fake network link in
 # between.
 class ConnectionPair:
-    def __init__(self):
+    def __init__(self) -> None:
         self.conn = {CLIENT: Connection(CLIENT), SERVER: Connection(SERVER)}
         self.other = {CLIENT: SERVER, SERVER: CLIENT}
 
     @property
-    def conns(self):
+    def conns(self) -> ValuesView[Connection]:
         return self.conn.values()
 
     # expect="match" if expect=send_events; expect=[...] to say what expected
-    def send(self, role, send_events, expect="match"):
+    def send(
+        self,
+        role: Type[Sentinel],
+        send_events: Union[List[Event], Event],
+        expect: Union[List[Event], Event, Literal["match"]] = "match",
+    ) -> bytes:
         if not isinstance(send_events, list):
             send_events = [send_events]
         data = b""
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_against_stdlib_http.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_against_stdlib_http.py
index e6c5db4..d2ee131 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_against_stdlib_http.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_against_stdlib_http.py
@@ -5,13 +5,16 @@
 import threading
 from contextlib import closing, contextmanager
 from http.server import SimpleHTTPRequestHandler
+from typing import Callable, Generator
 from urllib.request import urlopen
 
 import h11
 
 
 @contextmanager
-def socket_server(handler):
+def socket_server(
+    handler: Callable[..., socketserver.BaseRequestHandler]
+) -> Generator[socketserver.TCPServer, None, None]:
     httpd = socketserver.TCPServer(("127.0.0.1", 0), handler)
     thread = threading.Thread(
         target=httpd.serve_forever, kwargs={"poll_interval": 0.01}
@@ -30,23 +33,23 @@ def socket_server(handler):
 
 
 class SingleMindedRequestHandler(SimpleHTTPRequestHandler):
-    def translate_path(self, path):
+    def translate_path(self, path: str) -> str:
         return test_file_path
 
 
-def test_h11_as_client():
+def test_h11_as_client() -> None:
     with socket_server(SingleMindedRequestHandler) as httpd:
         with closing(socket.create_connection(httpd.server_address)) as s:
             c = h11.Connection(h11.CLIENT)
 
             s.sendall(
-                c.send(
+                c.send(  # type: ignore[arg-type]
                     h11.Request(
                         method="GET", target="/foo", headers=[("Host", "localhost")]
                     )
                 )
             )
-            s.sendall(c.send(h11.EndOfMessage()))
+            s.sendall(c.send(h11.EndOfMessage()))  # type: ignore[arg-type]
 
             data = bytearray()
             while True:
@@ -67,7 +70,7 @@ def test_h11_as_client():
 
 
 class H11RequestHandler(socketserver.BaseRequestHandler):
-    def handle(self):
+    def handle(self) -> None:
         with closing(self.request) as s:
             c = h11.Connection(h11.SERVER)
             request = None
@@ -82,6 +85,7 @@ def handle(self):
                     request = event
                 if type(event) is h11.EndOfMessage:
                     break
+            assert request is not None
             info = json.dumps(
                 {
                     "method": request.method.decode("ascii"),
@@ -92,12 +96,12 @@ def handle(self):
                     },
                 }
             )
-            s.sendall(c.send(h11.Response(status_code=200, headers=[])))
+            s.sendall(c.send(h11.Response(status_code=200, headers=[])))  # type: ignore[arg-type]
             s.sendall(c.send(h11.Data(data=info.encode("ascii"))))
             s.sendall(c.send(h11.EndOfMessage()))
 
 
-def test_h11_as_server():
+def test_h11_as_server() -> None:
     with socket_server(H11RequestHandler) as httpd:
         host, port = httpd.server_address
         url = "http://{}:{}/some-path".format(host, port)
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_connection.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_connection.py
index baadec8..73a27b9 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_connection.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_connection.py
@@ -1,13 +1,35 @@
+from typing import Any, cast, Dict, List, Optional, Tuple, Type
+
 import pytest
 
 from .._connection import _body_framing, _keep_alive, Connection, NEED_DATA, PAUSED
-from .._events import *
-from .._state import *
-from .._util import LocalProtocolError, RemoteProtocolError
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from .._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    ERROR,
+    IDLE,
+    MIGHT_SWITCH_PROTOCOL,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
+from .._util import LocalProtocolError, RemoteProtocolError, Sentinel
 from .helpers import ConnectionPair, get_all_events, receive_and_get
 
 
-def test__keep_alive():
+def test__keep_alive() -> None:
     assert _keep_alive(
         Request(method="GET", target="/", headers=[("Host", "Example.com")])
     )
@@ -26,19 +48,19 @@ def test__keep_alive():
         )
     )
     assert not _keep_alive(
-        Request(method="GET", target="/", headers=[], http_version="1.0")
+        Request(method="GET", target="/", headers=[], http_version="1.0")  # type: ignore[arg-type]
     )
 
-    assert _keep_alive(Response(status_code=200, headers=[]))
+    assert _keep_alive(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     assert not _keep_alive(Response(status_code=200, headers=[("Connection", "close")]))
     assert not _keep_alive(
         Response(status_code=200, headers=[("Connection", "a, b, cLOse, foo")])
     )
-    assert not _keep_alive(Response(status_code=200, headers=[], http_version="1.0"))
+    assert not _keep_alive(Response(status_code=200, headers=[], http_version="1.0"))  # type: ignore[arg-type]
 
 
-def test__body_framing():
-    def headers(cl, te):
+def test__body_framing() -> None:
+    def headers(cl: Optional[int], te: bool) -> List[Tuple[str, str]]:
         headers = []
         if cl is not None:
             headers.append(("Content-Length", str(cl)))
@@ -46,16 +68,19 @@ def headers(cl, te):
             headers.append(("Transfer-Encoding", "chunked"))
         return headers
 
-    def resp(status_code=200, cl=None, te=False):
+    def resp(
+        status_code: int = 200, cl: Optional[int] = None, te: bool = False
+    ) -> Response:
         return Response(status_code=status_code, headers=headers(cl, te))
 
-    def req(cl=None, te=False):
+    def req(cl: Optional[int] = None, te: bool = False) -> Request:
         h = headers(cl, te)
         h += [("Host", "example.com")]
         return Request(method="GET", target="/", headers=h)
 
     # Special cases where the headers are ignored:
     for kwargs in [{}, {"cl": 100}, {"te": True}, {"cl": 100, "te": True}]:
+        kwargs = cast(Dict[str, Any], kwargs)
         for meth, r in [
             (b"HEAD", resp(**kwargs)),
             (b"GET", resp(status_code=204, **kwargs)),
@@ -65,21 +90,22 @@ def req(cl=None, te=False):
 
     # Transfer-encoding
     for kwargs in [{"te": True}, {"cl": 100, "te": True}]:
-        for meth, r in [(None, req(**kwargs)), (b"GET", resp(**kwargs))]:
+        kwargs = cast(Dict[str, Any], kwargs)
+        for meth, r in [(None, req(**kwargs)), (b"GET", resp(**kwargs))]:  # type: ignore
             assert _body_framing(meth, r) == ("chunked", ())
 
     # Content-Length
-    for meth, r in [(None, req(cl=100)), (b"GET", resp(cl=100))]:
+    for meth, r in [(None, req(cl=100)), (b"GET", resp(cl=100))]:  # type: ignore
         assert _body_framing(meth, r) == ("content-length", (100,))
 
     # No headers
-    assert _body_framing(None, req()) == ("content-length", (0,))
+    assert _body_framing(None, req()) == ("content-length", (0,))  # type: ignore
     assert _body_framing(b"GET", resp()) == ("http/1.0", ())
 
 
-def test_Connection_basics_and_content_length():
+def test_Connection_basics_and_content_length() -> None:
     with pytest.raises(ValueError):
-        Connection("CLIENT")
+        Connection("CLIENT")  # type: ignore
 
     p = ConnectionPair()
     assert p.conn[CLIENT].our_role is CLIENT
@@ -109,7 +135,7 @@ def test_Connection_basics_and_content_length():
     assert p.conn[CLIENT].their_http_version is None
     assert p.conn[SERVER].their_http_version == b"1.1"
 
-    data = p.send(SERVER, InformationalResponse(status_code=100, headers=[]))
+    data = p.send(SERVER, InformationalResponse(status_code=100, headers=[]))  # type: ignore[arg-type]
     assert data == b"HTTP/1.1 100 \r\n\r\n"
 
     data = p.send(SERVER, Response(status_code=200, headers=[("Content-Length", "11")]))
@@ -144,7 +170,7 @@ def test_Connection_basics_and_content_length():
         assert conn.states == {CLIENT: DONE, SERVER: DONE}
 
 
-def test_chunked():
+def test_chunked() -> None:
     p = ConnectionPair()
 
     p.send(
@@ -175,7 +201,7 @@ def test_chunked():
         assert conn.states == {CLIENT: DONE, SERVER: DONE}
 
 
-def test_chunk_boundaries():
+def test_chunk_boundaries() -> None:
     conn = Connection(our_role=SERVER)
 
     request = (
@@ -214,14 +240,14 @@ def test_chunk_boundaries():
     assert conn.next_event() == EndOfMessage()
 
 
-def test_client_talking_to_http10_server():
+def test_client_talking_to_http10_server() -> None:
     c = Connection(CLIENT)
     c.send(Request(method="GET", target="/", headers=[("Host", "example.com")]))
     c.send(EndOfMessage())
     assert c.our_state is DONE
     # No content-length, so Http10 framing for body
     assert receive_and_get(c, b"HTTP/1.0 200 OK\r\n\r\n") == [
-        Response(status_code=200, headers=[], http_version="1.0", reason=b"OK")
+        Response(status_code=200, headers=[], http_version="1.0", reason=b"OK")  # type: ignore[arg-type]
     ]
     assert c.our_state is MUST_CLOSE
     assert receive_and_get(c, b"12345") == [Data(data=b"12345")]
@@ -230,19 +256,19 @@ def test_client_talking_to_http10_server():
     assert c.their_state is CLOSED
 
 
-def test_server_talking_to_http10_client():
+def test_server_talking_to_http10_client() -> None:
     c = Connection(SERVER)
     # No content-length, so no body
     # NB: no host header
     assert receive_and_get(c, b"GET / HTTP/1.0\r\n\r\n") == [
-        Request(method="GET", target="/", headers=[], http_version="1.0"),
+        Request(method="GET", target="/", headers=[], http_version="1.0"),  # type: ignore[arg-type]
         EndOfMessage(),
     ]
     assert c.their_state is MUST_CLOSE
 
     # We automatically Connection: close back at them
     assert (
-        c.send(Response(status_code=200, headers=[]))
+        c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
         == b"HTTP/1.1 200 \r\nConnection: close\r\n\r\n"
     )
 
@@ -267,7 +293,7 @@ def test_server_talking_to_http10_client():
     assert receive_and_get(c, b"") == [ConnectionClosed()]
 
 
-def test_automatic_transfer_encoding_in_response():
+def test_automatic_transfer_encoding_in_response() -> None:
     # Check that in responses, the user can specify either Transfer-Encoding:
     # chunked or no framing at all, and in both cases we automatically select
     # the right option depending on whether the peer speaks HTTP/1.0 or
@@ -279,6 +305,7 @@ def test_automatic_transfer_encoding_in_response():
         # because if both are set then Transfer-Encoding wins
         [("Transfer-Encoding", "chunked"), ("Content-Length", "100")],
     ]:
+        user_headers = cast(List[Tuple[str, str]], user_headers)
         p = ConnectionPair()
         p.send(
             CLIENT,
@@ -308,7 +335,7 @@ def test_automatic_transfer_encoding_in_response():
         assert c.send(Data(data=b"12345")) == b"12345"
 
 
-def test_automagic_connection_close_handling():
+def test_automagic_connection_close_handling() -> None:
     p = ConnectionPair()
     # If the user explicitly sets Connection: close, then we notice and
     # respect it
@@ -329,7 +356,7 @@ def test_automagic_connection_close_handling():
     p.send(
         SERVER,
         # no header here...
-        [Response(status_code=204, headers=[]), EndOfMessage()],
+        [Response(status_code=204, headers=[]), EndOfMessage()],  # type: ignore[arg-type]
         # ...but oh look, it arrived anyway
         expect=[
             Response(status_code=204, headers=[("connection", "close")]),
@@ -340,8 +367,8 @@ def test_automagic_connection_close_handling():
         assert conn.states == {CLIENT: MUST_CLOSE, SERVER: MUST_CLOSE}
 
 
-def test_100_continue():
-    def setup():
+def test_100_continue() -> None:
+    def setup() -> ConnectionPair:
         p = ConnectionPair()
         p.send(
             CLIENT,
@@ -363,7 +390,7 @@ def setup():
 
     # Disabled by 100 Continue
     p = setup()
-    p.send(SERVER, InformationalResponse(status_code=100, headers=[]))
+    p.send(SERVER, InformationalResponse(status_code=100, headers=[]))  # type: ignore[arg-type]
     for conn in p.conns:
         assert not conn.client_is_waiting_for_100_continue
         assert not conn.they_are_waiting_for_100_continue
@@ -385,7 +412,7 @@ def setup():
         assert not conn.they_are_waiting_for_100_continue
 
 
-def test_max_incomplete_event_size_countermeasure():
+def test_max_incomplete_event_size_countermeasure() -> None:
     # Infinitely long headers are definitely not okay
     c = Connection(SERVER)
     c.receive_data(b"GET / HTTP/1.0\r\nEndless: ")
@@ -444,7 +471,7 @@ def test_max_incomplete_event_size_countermeasure():
     # Even more data comes in, still no problem
     c.receive_data(b"X" * 1000)
     # We can respond and reuse to get the second pipelined request
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     c.start_next_cycle()
     assert get_all_events(c) == [
@@ -454,20 +481,26 @@ def test_max_incomplete_event_size_countermeasure():
     # But once we unpause and try to read the next message, and find that it's
     # incomplete and the buffer is *still* way too large, then *that's* a
     # problem:
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     c.start_next_cycle()
     with pytest.raises(RemoteProtocolError):
         c.next_event()
 
 
-def test_reuse_simple():
+def test_reuse_simple() -> None:
     p = ConnectionPair()
     p.send(
         CLIENT,
         [Request(method="GET", target="/", headers=[("Host", "a")]), EndOfMessage()],
     )
-    p.send(SERVER, [Response(status_code=200, headers=[]), EndOfMessage()])
+    p.send(
+        SERVER,
+        [
+            Response(status_code=200, headers=[(b"transfer-encoding", b"chunked")]),
+            EndOfMessage(),
+        ],
+    )
     for conn in p.conns:
         assert conn.states == {CLIENT: DONE, SERVER: DONE}
         conn.start_next_cycle()
@@ -479,10 +512,16 @@ def test_reuse_simple():
             EndOfMessage(),
         ],
     )
-    p.send(SERVER, [Response(status_code=404, headers=[]), EndOfMessage()])
+    p.send(
+        SERVER,
+        [
+            Response(status_code=404, headers=[(b"transfer-encoding", b"chunked")]),
+            EndOfMessage(),
+        ],
+    )
 
 
-def test_pipelining():
+def test_pipelining() -> None:
     # Client doesn't support pipelining, so we have to do this by hand
     c = Connection(SERVER)
     assert c.next_event() is NEED_DATA
@@ -508,7 +547,7 @@ def test_pipelining():
 
     assert c.next_event() is PAUSED
 
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     assert c.their_state is DONE
     assert c.our_state is DONE
@@ -525,7 +564,7 @@ def test_pipelining():
         EndOfMessage(),
     ]
     assert c.next_event() is PAUSED
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     c.start_next_cycle()
 
@@ -535,7 +574,7 @@ def test_pipelining():
     ]
     # Doesn't pause this time, no trailing data
     assert c.next_event() is NEED_DATA
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
 
     # Arrival of more data triggers pause
@@ -554,7 +593,7 @@ def test_pipelining():
         c.receive_data(b"FDSA")
 
 
-def test_protocol_switch():
+def test_protocol_switch() -> None:
     for (req, deny, accept) in [
         (
             Request(
@@ -562,8 +601,8 @@ def test_protocol_switch():
                 target="example.com:443",
                 headers=[("Host", "foo"), ("Content-Length", "1")],
             ),
-            Response(status_code=404, headers=[]),
-            Response(status_code=200, headers=[]),
+            Response(status_code=404, headers=[(b"transfer-encoding", b"chunked")]),
+            Response(status_code=200, headers=[(b"transfer-encoding", b"chunked")]),
         ),
         (
             Request(
@@ -571,7 +610,7 @@ def test_protocol_switch():
                 target="/",
                 headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
             ),
-            Response(status_code=200, headers=[]),
+            Response(status_code=200, headers=[(b"transfer-encoding", b"chunked")]),
             InformationalResponse(status_code=101, headers=[("Upgrade", "a")]),
         ),
         (
@@ -580,9 +619,9 @@ def test_protocol_switch():
                 target="example.com:443",
                 headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
             ),
-            Response(status_code=404, headers=[]),
+            Response(status_code=404, headers=[(b"transfer-encoding", b"chunked")]),
             # Accept CONNECT, not upgrade
-            Response(status_code=200, headers=[]),
+            Response(status_code=200, headers=[(b"transfer-encoding", b"chunked")]),
         ),
         (
             Request(
@@ -590,13 +629,13 @@ def test_protocol_switch():
                 target="example.com:443",
                 headers=[("Host", "foo"), ("Content-Length", "1"), ("Upgrade", "a, b")],
             ),
-            Response(status_code=404, headers=[]),
+            Response(status_code=404, headers=[(b"transfer-encoding", b"chunked")]),
             # Accept Upgrade, not CONNECT
             InformationalResponse(status_code=101, headers=[("Upgrade", "b")]),
         ),
     ]:
 
-        def setup():
+        def setup() -> ConnectionPair:
             p = ConnectionPair()
             p.send(CLIENT, req)
             # No switch-related state change stuff yet; the client has to
@@ -644,7 +683,7 @@ def setup():
         sc.send(EndOfMessage())
         sc.start_next_cycle()
         assert get_all_events(sc) == [
-            Request(method="GET", target="/", headers=[], http_version="1.0"),
+            Request(method="GET", target="/", headers=[], http_version="1.0"),  # type: ignore[arg-type]
             EndOfMessage(),
         ]
 
@@ -661,7 +700,7 @@ def setup():
 
         p = setup()
         sc = p.conn[SERVER]
-        sc.receive_data(b"") == []
+        sc.receive_data(b"")
         assert sc.next_event() is PAUSED
         sc.send(deny)
         assert sc.next_event() == ConnectionClosed()
@@ -679,12 +718,12 @@ def setup():
             p.conn[SERVER].send(Data(data=b"123"))
 
 
-def test_close_simple():
+def test_close_simple() -> None:
     # Just immediately closing a new connection without anything having
     # happened yet.
     for (who_shot_first, who_shot_second) in [(CLIENT, SERVER), (SERVER, CLIENT)]:
 
-        def setup():
+        def setup() -> ConnectionPair:
             p = ConnectionPair()
             p.send(who_shot_first, ConnectionClosed())
             for conn in p.conns:
@@ -720,12 +759,15 @@ def setup():
             p.conn[who_shot_first].next_event()
 
 
-def test_close_different_states():
+def test_close_different_states() -> None:
     req = [
         Request(method="GET", target="/foo", headers=[("Host", "a")]),
         EndOfMessage(),
     ]
-    resp = [Response(status_code=200, headers=[]), EndOfMessage()]
+    resp = [
+        Response(status_code=200, headers=[(b"transfer-encoding", b"chunked")]),
+        EndOfMessage(),
+    ]
 
     # Client before request
     p = ConnectionPair()
@@ -783,7 +825,7 @@ def test_close_different_states():
 
 # Receive several requests and then client shuts down their side of the
 # connection; we can respond to each
-def test_pipelined_close():
+def test_pipelined_close() -> None:
     c = Connection(SERVER)
     # 2 requests then a close
     c.receive_data(
@@ -803,7 +845,7 @@ def test_pipelined_close():
         EndOfMessage(),
     ]
     assert c.states[CLIENT] is DONE
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     assert c.states[SERVER] is DONE
     c.start_next_cycle()
@@ -818,21 +860,23 @@ def test_pipelined_close():
         ConnectionClosed(),
     ]
     assert c.states == {CLIENT: CLOSED, SERVER: SEND_RESPONSE}
-    c.send(Response(status_code=200, headers=[]))
+    c.send(Response(status_code=200, headers=[]))  # type: ignore[arg-type]
     c.send(EndOfMessage())
     assert c.states == {CLIENT: CLOSED, SERVER: MUST_CLOSE}
     c.send(ConnectionClosed())
     assert c.states == {CLIENT: CLOSED, SERVER: CLOSED}
 
 
-def test_sendfile():
+def test_sendfile() -> None:
     class SendfilePlaceholder:
-        def __len__(self):
+        def __len__(self) -> int:
             return 10
 
     placeholder = SendfilePlaceholder()
 
-    def setup(header, http_version):
+    def setup(
+        header: Tuple[str, str], http_version: str
+    ) -> Tuple[Connection, Optional[List[bytes]]]:
         c = Connection(SERVER)
         receive_and_get(
             c, "GET / HTTP/{}\r\nHost: a\r\n\r\n".format(http_version).encode("ascii")
@@ -841,25 +885,25 @@ def setup(header, http_version):
         if header:
             headers.append(header)
         c.send(Response(status_code=200, headers=headers))
-        return c, c.send_with_data_passthrough(Data(data=placeholder))
+        return c, c.send_with_data_passthrough(Data(data=placeholder))  # type: ignore
 
     c, data = setup(("Content-Length", "10"), "1.1")
-    assert data == [placeholder]
+    assert data == [placeholder]  # type: ignore
     # Raises an error if the connection object doesn't think we've sent
     # exactly 10 bytes
     c.send(EndOfMessage())
 
     _, data = setup(("Transfer-Encoding", "chunked"), "1.1")
-    assert placeholder in data
-    data[data.index(placeholder)] = b"x" * 10
-    assert b"".join(data) == b"a\r\nxxxxxxxxxx\r\n"
+    assert placeholder in data  # type: ignore
+    data[data.index(placeholder)] = b"x" * 10  # type: ignore
+    assert b"".join(data) == b"a\r\nxxxxxxxxxx\r\n"  # type: ignore
 
-    c, data = setup(None, "1.0")
-    assert data == [placeholder]
+    c, data = setup(None, "1.0")  # type: ignore
+    assert data == [placeholder]  # type: ignore
     assert c.our_state is SEND_BODY
 
 
-def test_errors():
+def test_errors() -> None:
     # After a receive error, you can't receive
     for role in [CLIENT, SERVER]:
         c = Connection(our_role=role)
@@ -875,14 +919,14 @@ def test_errors():
         # But we can still yell at the client for sending us gibberish
         if role is SERVER:
             assert (
-                c.send(Response(status_code=400, headers=[]))
+                c.send(Response(status_code=400, headers=[]))  # type: ignore[arg-type]
                 == b"HTTP/1.1 400 \r\nConnection: close\r\n\r\n"
             )
 
     # After an error sending, you can no longer send
     # (This is especially important for things like content-length errors,
     # where there's complex internal state being modified)
-    def conn(role):
+    def conn(role: Type[Sentinel]) -> Connection:
         c = Connection(our_role=role)
         if role is SERVER:
             # Put it into the state where it *could* send a response...
@@ -902,8 +946,8 @@ def conn(role):
                 http_version="1.0",
             )
         elif role is SERVER:
-            good = Response(status_code=200, headers=[])
-            bad = Response(status_code=200, headers=[], http_version="1.0")
+            good = Response(status_code=200, headers=[])  # type: ignore[arg-type,assignment]
+            bad = Response(status_code=200, headers=[], http_version="1.0")  # type: ignore[arg-type,assignment]
         # Make sure 'good' actually is good
         c = conn(role)
         c.send(good)
@@ -929,14 +973,14 @@ def conn(role):
         assert c.their_state is not ERROR
 
 
-def test_idle_receive_nothing():
+def test_idle_receive_nothing() -> None:
     # At one point this incorrectly raised an error
     for role in [CLIENT, SERVER]:
         c = Connection(role)
         assert c.next_event() is NEED_DATA
 
 
-def test_connection_drop():
+def test_connection_drop() -> None:
     c = Connection(SERVER)
     c.receive_data(b"GET /")
     assert c.next_event() is NEED_DATA
@@ -945,15 +989,15 @@ def test_connection_drop():
         c.next_event()
 
 
-def test_408_request_timeout():
+def test_408_request_timeout() -> None:
     # Should be able to send this spontaneously as a server without seeing
     # anything from client
     p = ConnectionPair()
-    p.send(SERVER, Response(status_code=408, headers=[]))
+    p.send(SERVER, Response(status_code=408, headers=[(b"connection", b"close")]))
 
 
 # This used to raise IndexError
-def test_empty_request():
+def test_empty_request() -> None:
     c = Connection(SERVER)
     c.receive_data(b"\r\n")
     with pytest.raises(RemoteProtocolError):
@@ -961,7 +1005,7 @@ def test_empty_request():
 
 
 # This used to raise IndexError
-def test_empty_response():
+def test_empty_response() -> None:
     c = Connection(CLIENT)
     c.send(Request(method="GET", target="/", headers=[("Host", "a")]))
     c.receive_data(b"\r\n")
@@ -977,7 +1021,7 @@ def test_empty_response():
         b"\x16\x03\x01\x00\xa5",  # Typical start of a TLS Client Hello
     ],
 )
-def test_early_detection_of_invalid_request(data):
+def test_early_detection_of_invalid_request(data: bytes) -> None:
     c = Connection(SERVER)
     # Early detection should occur before even receiving a `\r\n`
     c.receive_data(data)
@@ -993,7 +1037,7 @@ def test_early_detection_of_invalid_request(data):
         b"\x16\x03\x03\x00\x31",  # Typical start of a TLS Server Hello
     ],
 )
-def test_early_detection_of_invalid_response(data):
+def test_early_detection_of_invalid_response(data: bytes) -> None:
     c = Connection(CLIENT)
     # Early detection should occur before even receiving a `\r\n`
     c.receive_data(data)
@@ -1005,8 +1049,8 @@ def test_early_detection_of_invalid_response(data):
 # The correct way to handle HEAD is to put whatever headers we *would* have
 # put if it were a GET -- even though we know that for HEAD, those headers
 # will be ignored.
-def test_HEAD_framing_headers():
-    def setup(method, http_version):
+def test_HEAD_framing_headers() -> None:
+    def setup(method: bytes, http_version: bytes) -> Connection:
         c = Connection(SERVER)
         c.receive_data(
             method + b" / HTTP/" + http_version + b"\r\n" + b"Host: example.com\r\n\r\n"
@@ -1019,14 +1063,14 @@ def setup(method, http_version):
         # No Content-Length, HTTP/1.1 peer, should use chunked
         c = setup(method, b"1.1")
         assert (
-            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"
+            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"  # type: ignore[arg-type]
             b"Transfer-Encoding: chunked\r\n\r\n"
         )
 
         # No Content-Length, HTTP/1.0 peer, frame with connection: close
         c = setup(method, b"1.0")
         assert (
-            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"
+            c.send(Response(status_code=200, headers=[])) == b"HTTP/1.1 200 \r\n"  # type: ignore[arg-type]
             b"Connection: close\r\n\r\n"
         )
 
@@ -1047,7 +1091,7 @@ def setup(method, http_version):
         )
 
 
-def test_special_exceptions_for_lost_connection_in_message_body():
+def test_special_exceptions_for_lost_connection_in_message_body() -> None:
     c = Connection(SERVER)
     c.receive_data(
         b"POST / HTTP/1.1\r\n" b"Host: example.com\r\n" b"Content-Length: 100\r\n\r\n"
@@ -1071,7 +1115,7 @@ def test_special_exceptions_for_lost_connection_in_message_body():
     assert type(c.next_event()) is Request
     assert c.next_event() is NEED_DATA
     c.receive_data(b"8\r\n012345")
-    assert c.next_event().data == b"012345"
+    assert c.next_event().data == b"012345"  # type: ignore
     c.receive_data(b"")
     with pytest.raises(RemoteProtocolError) as excinfo:
         c.next_event()
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_events.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_events.py
index e20f741..bc6c313 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_events.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_events.py
@@ -3,57 +3,19 @@
 import pytest
 
 from .. import _events
-from .._events import *
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
 from .._util import LocalProtocolError
 
 
-def test_event_bundle():
-    class T(_events._EventBundle):
-        _fields = ["a", "b"]
-        _defaults = {"b": 1}
-
-        def _validate(self):
-            if self.a == 0:
-                raise ValueError
-
-    # basic construction and methods
-    t = T(a=1, b=0)
-    assert repr(t) == "T(a=1, b=0)"
-    assert t == T(a=1, b=0)
-    assert not (t == T(a=2, b=0))
-    assert not (t != T(a=1, b=0))
-    assert t != T(a=2, b=0)
-    with pytest.raises(TypeError):
-        hash(t)
-
-    # check defaults
-    t = T(a=10)
-    assert t.a == 10
-    assert t.b == 1
-
-    # no positional args
-    with pytest.raises(TypeError):
-        T(1)
-
-    with pytest.raises(TypeError):
-        T(1, a=1, b=0)
-
-    # unknown field
-    with pytest.raises(TypeError):
-        T(a=1, b=0, c=10)
-
-    # missing required field
-    with pytest.raises(TypeError) as exc:
-        T(b=0)
-    # make sure we error on the right missing kwarg
-    assert "kwarg a" in str(exc.value)
-
-    # _validate is called
-    with pytest.raises(ValueError):
-        T(a=0, b=0)
-
-
-def test_events():
+def test_events() -> None:
     with pytest.raises(LocalProtocolError):
         # Missing Host:
         req = Request(
@@ -114,14 +76,23 @@ def test_events():
     )
 
     # Request target is validated
-    for bad_char in b"\x00\x20\x7f\xee":
+    for bad_byte in b"\x00\x20\x7f\xee":
         target = bytearray(b"/")
-        target.append(bad_char)
+        target.append(bad_byte)
         with pytest.raises(LocalProtocolError):
             Request(
                 method="GET", target=target, headers=[("Host", "a")], http_version="1.1"
             )
 
+    # Request method is validated
+    with pytest.raises(LocalProtocolError):
+        Request(
+            method="GET / HTTP/1.1",
+            target=target,
+            headers=[("Host", "a")],
+            http_version="1.1",
+        )
+
     ir = InformationalResponse(status_code=100, headers=[("Host", "a")])
     assert ir.status_code == 100
     assert ir.headers == [(b"host", b"a")]
@@ -130,19 +101,19 @@ def test_events():
     with pytest.raises(LocalProtocolError):
         InformationalResponse(status_code=200, headers=[("Host", "a")])
 
-    resp = Response(status_code=204, headers=[], http_version="1.0")
+    resp = Response(status_code=204, headers=[], http_version="1.0")  # type: ignore[arg-type]
     assert resp.status_code == 204
     assert resp.headers == []
     assert resp.http_version == b"1.0"
 
     with pytest.raises(LocalProtocolError):
-        resp = Response(status_code=100, headers=[], http_version="1.0")
+        resp = Response(status_code=100, headers=[], http_version="1.0")  # type: ignore[arg-type]
 
     with pytest.raises(LocalProtocolError):
-        Response(status_code="100", headers=[], http_version="1.0")
+        Response(status_code="100", headers=[], http_version="1.0")  # type: ignore[arg-type]
 
     with pytest.raises(LocalProtocolError):
-        InformationalResponse(status_code=b"100", headers=[], http_version="1.0")
+        InformationalResponse(status_code=b"100", headers=[], http_version="1.0")  # type: ignore[arg-type]
 
     d = Data(data=b"asdf")
     assert d.data == b"asdf"
@@ -154,16 +125,16 @@ def test_events():
     assert repr(cc) == "ConnectionClosed()"
 
 
-def test_intenum_status_code():
+def test_intenum_status_code() -> None:
     # https://github.com/python-hyper/h11/issues/72
 
-    r = Response(status_code=HTTPStatus.OK, headers=[], http_version="1.0")
+    r = Response(status_code=HTTPStatus.OK, headers=[], http_version="1.0")  # type: ignore[arg-type]
     assert r.status_code == HTTPStatus.OK
     assert type(r.status_code) is not type(HTTPStatus.OK)
     assert type(r.status_code) is int
 
 
-def test_header_casing():
+def test_header_casing() -> None:
     r = Request(
         method="GET",
         target="/",
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_headers.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_headers.py
index ff3dc8d..ba53d08 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_headers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_headers.py
@@ -1,9 +1,17 @@
 import pytest
 
-from .._headers import *
-
-
-def test_normalize_and_validate():
+from .._events import Request
+from .._headers import (
+    get_comma_header,
+    has_expect_100_continue,
+    Headers,
+    normalize_and_validate,
+    set_comma_header,
+)
+from .._util import LocalProtocolError
+
+
+def test_normalize_and_validate() -> None:
     assert normalize_and_validate([("foo", "bar")]) == [(b"foo", b"bar")]
     assert normalize_and_validate([(b"foo", b"bar")]) == [(b"foo", b"bar")]
 
@@ -84,7 +92,7 @@ def test_normalize_and_validate():
     assert excinfo.value.error_status_hint == 501  # Not Implemented
 
 
-def test_get_set_comma_header():
+def test_get_set_comma_header() -> None:
     headers = normalize_and_validate(
         [
             ("Connection", "close"),
@@ -95,10 +103,10 @@ def test_get_set_comma_header():
 
     assert get_comma_header(headers, b"connection") == [b"close", b"foo", b"bar"]
 
-    headers = set_comma_header(headers, b"newthing", ["a", "b"])
+    headers = set_comma_header(headers, b"newthing", ["a", "b"])  # type: ignore
 
     with pytest.raises(LocalProtocolError):
-        set_comma_header(headers, b"newthing", ["  a", "b"])
+        set_comma_header(headers, b"newthing", ["  a", "b"])  # type: ignore
 
     assert headers == [
         (b"connection", b"close"),
@@ -108,7 +116,7 @@ def test_get_set_comma_header():
         (b"newthing", b"b"),
     ]
 
-    headers = set_comma_header(headers, b"whatever", ["different thing"])
+    headers = set_comma_header(headers, b"whatever", ["different thing"])  # type: ignore
 
     assert headers == [
         (b"connection", b"close"),
@@ -119,9 +127,7 @@ def test_get_set_comma_header():
     ]
 
 
-def test_has_100_continue():
-    from .._events import Request
-
+def test_has_100_continue() -> None:
     assert has_expect_100_continue(
         Request(
             method="GET",
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_helpers.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_helpers.py
index 1477947..c329c76 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_helpers.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_helpers.py
@@ -1,12 +1,21 @@
-from .helpers import *
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from .helpers import normalize_data_events
 
 
-def test_normalize_data_events():
+def test_normalize_data_events() -> None:
     assert normalize_data_events(
         [
             Data(data=bytearray(b"1")),
             Data(data=b"2"),
-            Response(status_code=200, headers=[]),
+            Response(status_code=200, headers=[]),  # type: ignore[arg-type]
             Data(data=b"3"),
             Data(data=b"4"),
             EndOfMessage(),
@@ -16,7 +25,7 @@ def test_normalize_data_events():
         ]
     ) == [
         Data(data=b"12"),
-        Response(status_code=200, headers=[]),
+        Response(status_code=200, headers=[]),  # type: ignore[arg-type]
         Data(data=b"34"),
         EndOfMessage(),
         Data(data=b"567"),
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_io.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_io.py
index 459a627..2b47c0e 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_io.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_io.py
@@ -1,6 +1,16 @@
+from typing import Any, Callable, Generator, List
+
 import pytest
 
-from .._events import *
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
 from .._headers import Headers, normalize_and_validate
 from .._readers import (
     _obsolete_line_fold,
@@ -10,7 +20,18 @@
     READERS,
 )
 from .._receivebuffer import ReceiveBuffer
-from .._state import *
+from .._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    IDLE,
+    MIGHT_SWITCH_PROTOCOL,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
 from .._util import LocalProtocolError
 from .._writers import (
     ChunkedWriter,
@@ -40,7 +61,7 @@
     ),
     (
         (SERVER, SEND_RESPONSE),
-        Response(status_code=200, headers=[], reason=b"OK"),
+        Response(status_code=200, headers=[], reason=b"OK"),  # type: ignore[arg-type]
         b"HTTP/1.1 200 OK\r\n\r\n",
     ),
     (
@@ -52,36 +73,35 @@
     ),
     (
         (SERVER, SEND_RESPONSE),
-        InformationalResponse(status_code=101, headers=[], reason=b"Upgrade"),
+        InformationalResponse(status_code=101, headers=[], reason=b"Upgrade"),  # type: ignore[arg-type]
         b"HTTP/1.1 101 Upgrade\r\n\r\n",
     ),
 ]
 
 
-def dowrite(writer, obj):
-    got_list = []
+def dowrite(writer: Callable[..., None], obj: Any) -> bytes:
+    got_list: List[bytes] = []
     writer(obj, got_list.append)
     return b"".join(got_list)
 
 
-def tw(writer, obj, expected):
+def tw(writer: Any, obj: Any, expected: Any) -> None:
     got = dowrite(writer, obj)
     assert got == expected
 
 
-def makebuf(data):
+def makebuf(data: bytes) -> ReceiveBuffer:
     buf = ReceiveBuffer()
     buf += data
     return buf
 
 
-def tr(reader, data, expected):
-    def check(got):
+def tr(reader: Any, data: bytes, expected: Any) -> None:
+    def check(got: Any) -> None:
         assert got == expected
         # Headers should always be returned as bytes, not e.g. bytearray
         # https://github.com/python-hyper/wsproto/pull/54#issuecomment-377709478
         for name, value in getattr(got, "headers", []):
-            print(name, value)
             assert type(name) is bytes
             assert type(value) is bytes
 
@@ -104,17 +124,17 @@ def check(got):
     assert bytes(buf) == b"trailing"
 
 
-def test_writers_simple():
+def test_writers_simple() -> None:
     for ((role, state), event, binary) in SIMPLE_CASES:
         tw(WRITERS[role, state], event, binary)
 
 
-def test_readers_simple():
+def test_readers_simple() -> None:
     for ((role, state), event, binary) in SIMPLE_CASES:
         tr(READERS[role, state], binary, event)
 
 
-def test_writers_unusual():
+def test_writers_unusual() -> None:
     # Simple test of the write_headers utility routine
     tw(
         write_headers,
@@ -145,7 +165,7 @@ def test_writers_unusual():
         )
 
 
-def test_readers_unusual():
+def test_readers_unusual() -> None:
     # Reading HTTP/1.0
     tr(
         READERS[CLIENT, IDLE],
@@ -162,7 +182,7 @@ def test_readers_unusual():
     tr(
         READERS[CLIENT, IDLE],
         b"HEAD /foo HTTP/1.0\r\n\r\n",
-        Request(method="HEAD", target="/foo", headers=[], http_version="1.0"),
+        Request(method="HEAD", target="/foo", headers=[], http_version="1.0"),  # type: ignore[arg-type]
     )
 
     tr(
@@ -305,7 +325,7 @@ def test_readers_unusual():
         tr(READERS[CLIENT, IDLE], b"HEAD /foo HTTP/1.1\r\n" b": line\r\n\r\n", None)
 
 
-def test__obsolete_line_fold_bytes():
+def test__obsolete_line_fold_bytes() -> None:
     # _obsolete_line_fold has a defensive cast to bytearray, which is
     # necessary to protect against O(n^2) behavior in case anyone ever passes
     # in regular bytestrings... but right now we never pass in regular
@@ -318,7 +338,9 @@ def test__obsolete_line_fold_bytes():
     ]
 
 
-def _run_reader_iter(reader, buf, do_eof):
+def _run_reader_iter(
+    reader: Any, buf: bytes, do_eof: bool
+) -> Generator[Any, None, None]:
     while True:
         event = reader(buf)
         if event is None:
@@ -333,12 +355,12 @@ def _run_reader_iter(reader, buf, do_eof):
         yield reader.read_eof()
 
 
-def _run_reader(*args):
+def _run_reader(*args: Any) -> List[Event]:
     events = list(_run_reader_iter(*args))
     return normalize_data_events(events)
 
 
-def t_body_reader(thunk, data, expected, do_eof=False):
+def t_body_reader(thunk: Any, data: bytes, expected: Any, do_eof: bool = False) -> None:
     # Simple: consume whole thing
     print("Test 1")
     buf = makebuf(data)
@@ -361,7 +383,7 @@ def t_body_reader(thunk, data, expected, do_eof=False):
         assert _run_reader(thunk(), buf, False) == expected
 
 
-def test_ContentLengthReader():
+def test_ContentLengthReader() -> None:
     t_body_reader(lambda: ContentLengthReader(0), b"", [EndOfMessage()])
 
     t_body_reader(
@@ -371,7 +393,7 @@ def test_ContentLengthReader():
     )
 
 
-def test_Http10Reader():
+def test_Http10Reader() -> None:
     t_body_reader(Http10Reader, b"", [EndOfMessage()], do_eof=True)
     t_body_reader(Http10Reader, b"asdf", [Data(data=b"asdf")], do_eof=False)
     t_body_reader(
@@ -379,7 +401,7 @@ def test_Http10Reader():
     )
 
 
-def test_ChunkedReader():
+def test_ChunkedReader() -> None:
     t_body_reader(ChunkedReader, b"0\r\n\r\n", [EndOfMessage()])
 
     t_body_reader(
@@ -433,8 +455,14 @@ def test_ChunkedReader():
         [Data(data=b"xxxxx"), EndOfMessage()],
     )
 
+    t_body_reader(
+        ChunkedReader,
+        b"5   	 \r\n01234\r\n" + b"0\r\n\r\n",
+        [Data(data=b"01234"), EndOfMessage()],
+    )
+
 
-def test_ContentLengthWriter():
+def test_ContentLengthWriter() -> None:
     w = ContentLengthWriter(5)
     assert dowrite(w, Data(data=b"123")) == b"123"
     assert dowrite(w, Data(data=b"45")) == b"45"
@@ -461,7 +489,7 @@ def test_ContentLengthWriter():
         dowrite(w, EndOfMessage(headers=[("Etag", "asdf")]))
 
 
-def test_ChunkedWriter():
+def test_ChunkedWriter() -> None:
     w = ChunkedWriter()
     assert dowrite(w, Data(data=b"aaa")) == b"3\r\naaa\r\n"
     assert dowrite(w, Data(data=b"a" * 20)) == b"14\r\n" + b"a" * 20 + b"\r\n"
@@ -476,7 +504,7 @@ def test_ChunkedWriter():
     )
 
 
-def test_Http10Writer():
+def test_Http10Writer() -> None:
     w = Http10Writer()
     assert dowrite(w, Data(data=b"1234")) == b"1234"
     assert dowrite(w, EndOfMessage()) == b""
@@ -485,12 +513,12 @@ def test_Http10Writer():
         dowrite(w, EndOfMessage(headers=[("Etag", "asdf")]))
 
 
-def test_reject_garbage_after_request_line():
+def test_reject_garbage_after_request_line() -> None:
     with pytest.raises(LocalProtocolError):
         tr(READERS[SERVER, SEND_RESPONSE], b"HTTP/1.0 200 OK\x00xxxx\r\n\r\n", None)
 
 
-def test_reject_garbage_after_response_line():
+def test_reject_garbage_after_response_line() -> None:
     with pytest.raises(LocalProtocolError):
         tr(
             READERS[CLIENT, IDLE],
@@ -499,7 +527,7 @@ def test_reject_garbage_after_response_line():
         )
 
 
-def test_reject_garbage_in_header_line():
+def test_reject_garbage_in_header_line() -> None:
     with pytest.raises(LocalProtocolError):
         tr(
             READERS[CLIENT, IDLE],
@@ -508,7 +536,7 @@ def test_reject_garbage_in_header_line():
         )
 
 
-def test_reject_non_vchar_in_path():
+def test_reject_non_vchar_in_path() -> None:
     for bad_char in b"\x00\x20\x7f\xee":
         message = bytearray(b"HEAD /")
         message.append(bad_char)
@@ -518,7 +546,7 @@ def test_reject_non_vchar_in_path():
 
 
 # https://github.com/python-hyper/h11/issues/57
-def test_allow_some_garbage_in_cookies():
+def test_allow_some_garbage_in_cookies() -> None:
     tr(
         READERS[CLIENT, IDLE],
         b"HEAD /foo HTTP/1.1\r\n"
@@ -536,7 +564,7 @@ def test_allow_some_garbage_in_cookies():
     )
 
 
-def test_host_comes_first():
+def test_host_comes_first() -> None:
     tw(
         write_headers,
         normalize_and_validate([("foo", "bar"), ("Host", "example.com")]),
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_receivebuffer.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_receivebuffer.py
index 3a61f9d..21a3870 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_receivebuffer.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_receivebuffer.py
@@ -1,11 +1,12 @@
 import re
+from typing import Tuple
 
 import pytest
 
 from .._receivebuffer import ReceiveBuffer
 
 
-def test_receivebuffer():
+def test_receivebuffer() -> None:
     b = ReceiveBuffer()
     assert not b
     assert len(b) == 0
@@ -118,7 +119,7 @@ def test_receivebuffer():
         ),
     ],
 )
-def test_receivebuffer_for_invalid_delimiter(data):
+def test_receivebuffer_for_invalid_delimiter(data: Tuple[bytes]) -> None:
     b = ReceiveBuffer()
 
     for line in data:
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_state.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_state.py
index efe83f0..bc974e6 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_state.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_state.py
@@ -1,12 +1,33 @@
 import pytest
 
-from .._events import *
-from .._state import *
-from .._state import _SWITCH_CONNECT, _SWITCH_UPGRADE, ConnectionState
+from .._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from .._state import (
+    _SWITCH_CONNECT,
+    _SWITCH_UPGRADE,
+    CLIENT,
+    CLOSED,
+    ConnectionState,
+    DONE,
+    IDLE,
+    MIGHT_SWITCH_PROTOCOL,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
 from .._util import LocalProtocolError
 
 
-def test_ConnectionState():
+def test_ConnectionState() -> None:
     cs = ConnectionState()
 
     # Basic event-triggered transitions
@@ -38,7 +59,7 @@ def test_ConnectionState():
     assert cs.states == {CLIENT: MUST_CLOSE, SERVER: CLOSED}
 
 
-def test_ConnectionState_keep_alive():
+def test_ConnectionState_keep_alive() -> None:
     # keep_alive = False
     cs = ConnectionState()
     cs.process_event(CLIENT, Request)
@@ -51,7 +72,7 @@ def test_ConnectionState_keep_alive():
     assert cs.states == {CLIENT: MUST_CLOSE, SERVER: MUST_CLOSE}
 
 
-def test_ConnectionState_keep_alive_in_DONE():
+def test_ConnectionState_keep_alive_in_DONE() -> None:
     # Check that if keep_alive is disabled when the CLIENT is already in DONE,
     # then this is sufficient to immediately trigger the DONE -> MUST_CLOSE
     # transition
@@ -63,7 +84,7 @@ def test_ConnectionState_keep_alive_in_DONE():
     assert cs.states[CLIENT] is MUST_CLOSE
 
 
-def test_ConnectionState_switch_denied():
+def test_ConnectionState_switch_denied() -> None:
     for switch_type in (_SWITCH_CONNECT, _SWITCH_UPGRADE):
         for deny_early in (True, False):
             cs = ConnectionState()
@@ -107,7 +128,7 @@ def test_ConnectionState_switch_denied():
 }
 
 
-def test_ConnectionState_protocol_switch_accepted():
+def test_ConnectionState_protocol_switch_accepted() -> None:
     for switch_event in [_SWITCH_UPGRADE, _SWITCH_CONNECT]:
         cs = ConnectionState()
         cs.process_client_switch_proposal(switch_event)
@@ -125,7 +146,7 @@ def test_ConnectionState_protocol_switch_accepted():
         assert cs.states == {CLIENT: SWITCHED_PROTOCOL, SERVER: SWITCHED_PROTOCOL}
 
 
-def test_ConnectionState_double_protocol_switch():
+def test_ConnectionState_double_protocol_switch() -> None:
     # CONNECT + Upgrade is legal! Very silly, but legal. So we support
     # it. Because sometimes doing the silly thing is easier than not.
     for server_switch in [None, _SWITCH_UPGRADE, _SWITCH_CONNECT]:
@@ -144,7 +165,7 @@ def test_ConnectionState_double_protocol_switch():
             assert cs.states == {CLIENT: SWITCHED_PROTOCOL, SERVER: SWITCHED_PROTOCOL}
 
 
-def test_ConnectionState_inconsistent_protocol_switch():
+def test_ConnectionState_inconsistent_protocol_switch() -> None:
     for client_switches, server_switch in [
         ([], _SWITCH_CONNECT),
         ([], _SWITCH_UPGRADE),
@@ -152,14 +173,14 @@ def test_ConnectionState_inconsistent_protocol_switch():
         ([_SWITCH_CONNECT], _SWITCH_UPGRADE),
     ]:
         cs = ConnectionState()
-        for client_switch in client_switches:
+        for client_switch in client_switches:  # type: ignore[attr-defined]
             cs.process_client_switch_proposal(client_switch)
         cs.process_event(CLIENT, Request)
         with pytest.raises(LocalProtocolError):
             cs.process_event(SERVER, Response, server_switch)
 
 
-def test_ConnectionState_keepalive_protocol_switch_interaction():
+def test_ConnectionState_keepalive_protocol_switch_interaction() -> None:
     # keep_alive=False + pending_switch_proposals
     cs = ConnectionState()
     cs.process_client_switch_proposal(_SWITCH_UPGRADE)
@@ -177,7 +198,7 @@ def test_ConnectionState_keepalive_protocol_switch_interaction():
     assert cs.states == {CLIENT: MUST_CLOSE, SERVER: SEND_BODY}
 
 
-def test_ConnectionState_reuse():
+def test_ConnectionState_reuse() -> None:
     cs = ConnectionState()
 
     with pytest.raises(LocalProtocolError):
@@ -242,7 +263,7 @@ def test_ConnectionState_reuse():
     assert cs.states == {CLIENT: IDLE, SERVER: IDLE}
 
 
-def test_server_request_is_illegal():
+def test_server_request_is_illegal() -> None:
     # There used to be a bug in how we handled the Request special case that
     # made this allowed...
     cs = ConnectionState()
diff --git a/addon/globalPlugins/spellcheck/libs/h11/tests/test_util.py b/addon/globalPlugins/spellcheck/libs/h11/tests/test_util.py
index d851bdc..79bc095 100644
--- a/addon/globalPlugins/spellcheck/libs/h11/tests/test_util.py
+++ b/addon/globalPlugins/spellcheck/libs/h11/tests/test_util.py
@@ -1,18 +1,26 @@
 import re
 import sys
 import traceback
+from typing import NoReturn
 
 import pytest
 
-from .._util import *
+from .._util import (
+    bytesify,
+    LocalProtocolError,
+    ProtocolError,
+    RemoteProtocolError,
+    Sentinel,
+    validate,
+)
 
 
-def test_ProtocolError():
+def test_ProtocolError() -> None:
     with pytest.raises(TypeError):
         ProtocolError("abstract base class")
 
 
-def test_LocalProtocolError():
+def test_LocalProtocolError() -> None:
     try:
         raise LocalProtocolError("foo")
     except LocalProtocolError as e:
@@ -25,7 +33,7 @@ def test_LocalProtocolError():
         assert str(e) == "foo"
         assert e.error_status_hint == 418
 
-    def thunk():
+    def thunk() -> NoReturn:
         raise LocalProtocolError("a", error_status_hint=420)
 
     try:
@@ -42,8 +50,8 @@ def thunk():
         assert new_traceback.endswith(orig_traceback)
 
 
-def test_validate():
-    my_re = re.compile(br"(?P<group1>[0-9]+)\.(?P<group2>[0-9]+)")
+def test_validate() -> None:
+    my_re = re.compile(rb"(?P<group1>[0-9]+)\.(?P<group2>[0-9]+)")
     with pytest.raises(LocalProtocolError):
         validate(my_re, b"0.")
 
@@ -57,8 +65,8 @@ def test_validate():
         validate(my_re, b"0.1\n")
 
 
-def test_validate_formatting():
-    my_re = re.compile(br"foo")
+def test_validate_formatting() -> None:
+    my_re = re.compile(rb"foo")
 
     with pytest.raises(LocalProtocolError) as excinfo:
         validate(my_re, b"", "oops")
@@ -73,21 +81,26 @@ def test_validate_formatting():
     assert "oops 10 xx" in str(excinfo.value)
 
 
-def test_make_sentinel():
-    S = make_sentinel("S")
+def test_make_sentinel() -> None:
+    class S(Sentinel, metaclass=Sentinel):
+        pass
+
     assert repr(S) == "S"
     assert S == S
     assert type(S).__name__ == "S"
     assert S in {S}
     assert type(S) is S
-    S2 = make_sentinel("S2")
+
+    class S2(Sentinel, metaclass=Sentinel):
+        pass
+
     assert repr(S2) == "S2"
     assert S != S2
     assert S not in {S2}
     assert type(S) is not type(S2)
 
 
-def test_bytesify():
+def test_bytesify() -> None:
     assert bytesify(b"123") == b"123"
     assert bytesify(bytearray(b"123")) == b"123"
     assert bytesify("123") == b"123"
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/__init__.py b/addon/globalPlugins/spellcheck/libs/httpcore/__init__.py
index 3ddc6d6..ea2a240 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/__init__.py
@@ -1,10 +1,25 @@
-from ._async.base import AsyncByteStream, AsyncHTTPTransport
-from ._async.connection_pool import AsyncConnectionPool
-from ._async.http_proxy import AsyncHTTPProxy
-from ._bytestreams import AsyncIteratorByteStream, ByteStream, IteratorByteStream
+from ._api import request, stream
+from ._async import (
+    AsyncConnectionInterface,
+    AsyncConnectionPool,
+    AsyncHTTP2Connection,
+    AsyncHTTP11Connection,
+    AsyncHTTPConnection,
+    AsyncHTTPProxy,
+    AsyncSOCKSProxy,
+)
+from ._backends.base import (
+    SOCKET_OPTION,
+    AsyncNetworkBackend,
+    AsyncNetworkStream,
+    NetworkBackend,
+    NetworkStream,
+)
+from ._backends.mock import AsyncMockBackend, AsyncMockStream, MockBackend, MockStream
+from ._backends.sync import SyncBackend
 from ._exceptions import (
-    CloseError,
     ConnectError,
+    ConnectionNotAvailable,
     ConnectTimeout,
     LocalProtocolError,
     NetworkError,
@@ -19,45 +34,106 @@
     WriteError,
     WriteTimeout,
 )
-from ._sync.base import SyncByteStream, SyncHTTPTransport
-from ._sync.connection_pool import SyncConnectionPool
-from ._sync.http_proxy import SyncHTTPProxy
+from ._models import URL, Origin, Request, Response
+from ._ssl import default_ssl_context
+from ._sync import (
+    ConnectionInterface,
+    ConnectionPool,
+    HTTP2Connection,
+    HTTP11Connection,
+    HTTPConnection,
+    HTTPProxy,
+    SOCKSProxy,
+)
+
+# The 'httpcore.AnyIOBackend' class is conditional on 'anyio' being installed.
+try:
+    from ._backends.anyio import AnyIOBackend
+except ImportError:  # pragma: nocover
+
+    class AnyIOBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = (
+                "Attempted to use 'httpcore.AnyIOBackend' but 'anyio' is not installed."
+            )
+            raise RuntimeError(msg)
+
+
+# The 'httpcore.TrioBackend' class is conditional on 'trio' being installed.
+try:
+    from ._backends.trio import TrioBackend
+except ImportError:  # pragma: nocover
+
+    class TrioBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = "Attempted to use 'httpcore.TrioBackend' but 'trio' is not installed."
+            raise RuntimeError(msg)
+
 
 __all__ = [
-    "AsyncByteStream",
+    # top-level requests
+    "request",
+    "stream",
+    # models
+    "Origin",
+    "URL",
+    "Request",
+    "Response",
+    # async
+    "AsyncHTTPConnection",
     "AsyncConnectionPool",
     "AsyncHTTPProxy",
-    "AsyncHTTPTransport",
-    "AsyncIteratorByteStream",
-    "ByteStream",
-    "CloseError",
-    "ConnectError",
-    "ConnectTimeout",
-    "IteratorByteStream",
-    "LocalProtocolError",
-    "NetworkError",
-    "PoolTimeout",
-    "ProtocolError",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+    # sync
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+    # network backends, implementations
+    "SyncBackend",
+    "AnyIOBackend",
+    "TrioBackend",
+    # network backends, mock implementations
+    "AsyncMockBackend",
+    "AsyncMockStream",
+    "MockBackend",
+    "MockStream",
+    # network backends, interface
+    "AsyncNetworkStream",
+    "AsyncNetworkBackend",
+    "NetworkStream",
+    "NetworkBackend",
+    # util
+    "default_ssl_context",
+    "SOCKET_OPTION",
+    # exceptions
+    "ConnectionNotAvailable",
     "ProxyError",
-    "ReadError",
-    "ReadTimeout",
+    "ProtocolError",
+    "LocalProtocolError",
     "RemoteProtocolError",
-    "SyncByteStream",
-    "SyncConnectionPool",
-    "SyncHTTPProxy",
-    "SyncHTTPTransport",
-    "TimeoutException",
     "UnsupportedProtocol",
-    "WriteError",
+    "TimeoutException",
+    "PoolTimeout",
+    "ConnectTimeout",
+    "ReadTimeout",
     "WriteTimeout",
+    "NetworkError",
+    "ConnectError",
+    "ReadError",
+    "WriteError",
 ]
-__version__ = "0.13.7"
 
-__locals = locals()
+__version__ = "1.0.4"
 
-for _name in __all__:
-    if not _name.startswith("__"):
-        # Save original source module, used by Sphinx.
-        __locals[_name].__source_module__ = __locals[_name].__module__
-        # Override module for prettier repr().
-        setattr(__locals[_name], "__module__", "httpcore")  # noqa
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "httpcore")  # noqa
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_api.py b/addon/globalPlugins/spellcheck/libs/httpcore/_api.py
new file mode 100644
index 0000000..854235f
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_api.py
@@ -0,0 +1,92 @@
+from contextlib import contextmanager
+from typing import Iterator, Optional, Union
+
+from ._models import URL, Extensions, HeaderTypes, Response
+from ._sync.connection_pool import ConnectionPool
+
+
+def request(
+    method: Union[bytes, str],
+    url: Union[URL, bytes, str],
+    *,
+    headers: HeaderTypes = None,
+    content: Union[bytes, Iterator[bytes], None] = None,
+    extensions: Optional[Extensions] = None,
+) -> Response:
+    """
+    Sends an HTTP request, returning the response.
+
+    ```
+    response = httpcore.request("GET", "https://www.example.com/")
+    ```
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore.Response`.
+    """
+    with ConnectionPool() as pool:
+        return pool.request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+
+
+@contextmanager
+def stream(
+    method: Union[bytes, str],
+    url: Union[URL, bytes, str],
+    *,
+    headers: HeaderTypes = None,
+    content: Union[bytes, Iterator[bytes], None] = None,
+    extensions: Optional[Extensions] = None,
+) -> Iterator[Response]:
+    """
+    Sends an HTTP request, returning the response within a content manager.
+
+    ```
+    with httpcore.stream("GET", "https://www.example.com/") as response:
+        ...
+    ```
+
+    When using the `stream()` function, the body of the response will not be
+    automatically read. If you want to access the response body you should
+    either use `content = response.read()`, or `for chunk in response.iter_content()`.
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore.Response`.
+    """
+    with ConnectionPool() as pool:
+        with pool.stream(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        ) as response:
+            yield response
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/__init__.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/__init__.py
index e69de29..88dc7f0 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/__init__.py
@@ -0,0 +1,39 @@
+from .connection import AsyncHTTPConnection
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .http_proxy import AsyncHTTPProxy
+from .interfaces import AsyncConnectionInterface
+
+try:
+    from .http2 import AsyncHTTP2Connection
+except ImportError:  # pragma: nocover
+
+    class AsyncHTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import AsyncSOCKSProxy
+except ImportError:  # pragma: nocover
+
+    class AsyncSOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "AsyncHTTPConnection",
+    "AsyncConnectionPool",
+    "AsyncHTTPProxy",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+]
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/base.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/base.py
deleted file mode 100644
index 2b3961c..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/base.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import enum
-from types import TracebackType
-from typing import AsyncIterator, Tuple, Type
-
-from .._types import URL, Headers, T
-
-
-class NewConnectionRequired(Exception):
-    pass
-
-
-class ConnectionState(enum.IntEnum):
-    """
-    PENDING  READY
-        |    |   ^
-        v    V   |
-        ACTIVE   |
-         |  |    |
-         |  V    |
-         V  IDLE-+
-       FULL   |
-         |    |
-         V    V
-         CLOSED
-    """
-
-    PENDING = 0  # Connection not yet acquired.
-    READY = 1  # Re-acquired from pool, about to send a request.
-    ACTIVE = 2  # Active requests.
-    FULL = 3  # Active requests, no more stream IDs available.
-    IDLE = 4  # No active requests.
-    CLOSED = 5  # Connection closed.
-
-
-class AsyncByteStream:
-    """
-    The base interface for request and response bodies.
-
-    Concrete implementations should subclass this class, and implement
-    the :meth:`__aiter__` method, and optionally the :meth:`aclose` method.
-    """
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        """
-        Yield bytes representing the request or response body.
-        """
-        yield b""  # pragma: nocover
-
-    async def aclose(self) -> None:
-        """
-        Must be called by the client to indicate that the stream has been closed.
-        """
-        pass  # pragma: nocover
-
-    async def aread(self) -> bytes:
-        try:
-            return b"".join([part async for part in self])
-        finally:
-            await self.aclose()
-
-
-class AsyncHTTPTransport:
-    """
-    The base interface for sending HTTP requests.
-
-    Concrete implementations should subclass this class, and implement
-    the :meth:`handle_async_request` method, and optionally the :meth:`aclose` method.
-    """
-
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        """
-        The interface for sending a single HTTP request, and returning a response.
-
-        Parameters
-        ----------
-        method:
-            The HTTP method, such as ``b'GET'``.
-        url:
-            The URL as a 4-tuple of (scheme, host, port, path).
-        headers:
-            Any HTTP headers to send with the request.
-        stream:
-            The body of the HTTP request.
-        extensions:
-            A dictionary of optional extensions.
-
-        Returns
-        -------
-        status_code:
-            The HTTP status code, such as ``200``.
-        headers:
-            Any HTTP headers included on the response.
-        stream:
-            The body of the HTTP response.
-        extensions:
-            A dictionary of optional extensions.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    async def aclose(self) -> None:
-        """
-        Close the implementation, which should close any outstanding response streams,
-        and any keep alive connections.
-        """
-
-    async def __aenter__(self: T) -> T:
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        await self.aclose()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection.py
index 2add4d8..2f439cf 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection.py
@@ -1,158 +1,109 @@
-from ssl import SSLContext
-from typing import List, Optional, Tuple, cast
-
-from .._backends.auto import AsyncBackend, AsyncLock, AsyncSocketStream, AutoBackend
+import itertools
+import logging
+import ssl
+from types import TracebackType
+from typing import Iterable, Iterator, Optional, Type
+
+from .._backends.auto import AutoBackend
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
 from .._exceptions import ConnectError, ConnectTimeout
-from .._types import URL, Headers, Origin, TimeoutDict
-from .._utils import exponential_backoff, get_logger, url_to_origin
-from .base import AsyncByteStream, AsyncHTTPTransport, NewConnectionRequired
-from .http import AsyncBaseHTTPConnection
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
 from .http11 import AsyncHTTP11Connection
-
-logger = get_logger(__name__)
+from .interfaces import AsyncConnectionInterface
 
 RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
 
 
-class AsyncHTTPConnection(AsyncHTTPTransport):
+logger = logging.getLogger("httpcore.connection")
+
+
+def exponential_backoff(factor: float) -> Iterator[float]:
+    """
+    Generate a geometric sequence that has a ratio of 2 and starts with 0.
+
+    For example:
+    - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...`
+    - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...`
+    """
+    yield 0
+    for n in itertools.count():
+        yield factor * 2**n
+
+
+class AsyncHTTPConnection(AsyncConnectionInterface):
     def __init__(
         self,
         origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        keepalive_expiry: Optional[float] = None,
         http1: bool = True,
         http2: bool = False,
-        keepalive_expiry: float = None,
-        uds: str = None,
-        ssl_context: SSLContext = None,
-        socket: AsyncSocketStream = None,
-        local_address: str = None,
         retries: int = 0,
-        backend: AsyncBackend = None,
-    ):
-        self.origin = origin
-        self._http1_enabled = http1
-        self._http2_enabled = http2
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
         self._keepalive_expiry = keepalive_expiry
-        self._uds = uds
-        self._ssl_context = SSLContext() if ssl_context is None else ssl_context
-        self.socket = socket
-        self._local_address = local_address
+        self._http1 = http1
+        self._http2 = http2
         self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
 
-        alpn_protocols: List[str] = []
-        if http1:
-            alpn_protocols.append("http/1.1")
-        if http2:
-            alpn_protocols.append("h2")
-
-        self._ssl_context.set_alpn_protocols(alpn_protocols)
-
-        self.connection: Optional[AsyncBaseHTTPConnection] = None
-        self._is_http11 = False
-        self._is_http2 = False
-        self._connect_failed = False
-        self._expires_at: Optional[float] = None
-        self._backend = AutoBackend() if backend is None else backend
-
-    def __repr__(self) -> str:
-        return f"<AsyncHTTPConnection [{self.info()}]>"
-
-    def info(self) -> str:
-        if self.connection is None:
-            return "Connection failed" if self._connect_failed else "Connecting"
-        return self.connection.info()
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        This occurs when any of the following occur:
-
-        * There are no active requests on an HTTP/1.1 connection, and the underlying
-          socket is readable. The only valid state the socket can be readable in
-          if this occurs is when the b"" EOF marker is about to be returned,
-          indicating a server disconnect.
-        * There are no active requests being made and the keepalive timeout has passed.
-        """
-        if self.connection is None:
-            return False
-        return self.connection.should_close()
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        if self.connection is None:
-            return False
-        return self.connection.is_idle()
+        self._network_backend: AsyncNetworkBackend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+        self._connection: Optional[AsyncConnectionInterface] = None
+        self._connect_failed: bool = False
+        self._request_lock = AsyncLock()
+        self._socket_options = socket_options
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection to {self._origin}"
+            )
 
-    def is_closed(self) -> bool:
-        if self.connection is None:
-            return self._connect_failed
-        return self.connection.is_closed()
+        try:
+            async with self._request_lock:
+                if self._connection is None:
+                    stream = await self._connect(request)
 
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        This occurs when any of the following occur:
-
-        * The connection has not yet been opened, and HTTP/2 support is enabled.
-          We don't *know* at this point if we'll end up on an HTTP/2 connection or
-          not, but we *might* do, so we indicate availability.
-        * The connection has been opened, and is currently idle.
-        * The connection is open, and is an HTTP/2 connection. The connection must
-          also not currently be exceeding the maximum number of allowable concurrent
-          streams and must not have exhausted the maximum total number of stream IDs.
-        """
-        if self.connection is None:
-            return self._http2_enabled and not self.is_closed
-        return self.connection.is_available()
-
-    @property
-    def request_lock(self) -> AsyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_request_lock"):
-            self._request_lock = self._backend.create_lock()
-        return self._request_lock
-
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        assert url_to_origin(url) == self.origin
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        async with self.request_lock:
-            if self.connection is None:
-                if self._connect_failed:
-                    raise NewConnectionRequired()
-                if not self.socket:
-                    logger.trace(
-                        "open_socket origin=%r timeout=%r", self.origin, timeout
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
                     )
-                    self.socket = await self._open_socket(timeout)
-                self._create_connection(self.socket)
-            elif not self.connection.is_available():
-                raise NewConnectionRequired()
-
-        assert self.connection is not None
-        logger.trace(
-            "connection.handle_async_request method=%r url=%r headers=%r",
-            method,
-            url,
-            headers,
-        )
-        return await self.connection.handle_async_request(
-            method, url, headers, stream, extensions
-        )
-
-    async def _open_socket(self, timeout: TimeoutDict = None) -> AsyncSocketStream:
-        scheme, hostname, port = self.origin
-        timeout = {} if timeout is None else timeout
-        ssl_context = self._ssl_context if scheme == b"https" else None
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+        except BaseException as exc:
+            self._connect_failed = True
+            raise exc
+
+        return await self._connection.handle_async_request(request)
+
+    async def _connect(self, request: Request) -> AsyncNetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
 
         retries_left = self._retries
         delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
@@ -160,61 +111,110 @@ async def _open_socket(self, timeout: TimeoutDict = None) -> AsyncSocketStream:
         while True:
             try:
                 if self._uds is None:
-                    return await self._backend.open_tcp_stream(
-                        hostname,
-                        port,
-                        ssl_context,
-                        timeout,
-                        local_address=self._local_address,
-                    )
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    async with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
                 else:
-                    return await self._backend.open_uds_stream(
-                        self._uds, hostname, ssl_context, timeout
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    async with Trace(
+                        "connect_unix_socket", logger, request, kwargs
+                    ) as trace:
+                        stream = await self._network_backend.connect_unix_socket(
+                            **kwargs
+                        )
+                        trace.return_value = stream
+
+                if self._origin.scheme in (b"https", b"wss"):
+                    ssl_context = (
+                        default_ssl_context()
+                        if self._ssl_context is None
+                        else self._ssl_context
                     )
+                    alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                    ssl_context.set_alpn_protocols(alpn_protocols)
+
+                    kwargs = {
+                        "ssl_context": ssl_context,
+                        "server_hostname": sni_hostname
+                        or self._origin.host.decode("ascii"),
+                        "timeout": timeout,
+                    }
+                    async with Trace("start_tls", logger, request, kwargs) as trace:
+                        stream = await stream.start_tls(**kwargs)
+                        trace.return_value = stream
+                return stream
             except (ConnectError, ConnectTimeout):
                 if retries_left <= 0:
-                    self._connect_failed = True
                     raise
                 retries_left -= 1
                 delay = next(delays)
-                await self._backend.sleep(delay)
-            except Exception:  # noqa: PIE786
-                self._connect_failed = True
-                raise
-
-    def _create_connection(self, socket: AsyncSocketStream) -> None:
-        http_version = socket.get_http_version()
-        logger.trace(
-            "create_connection socket=%r http_version=%r", socket, http_version
-        )
-        if http_version == "HTTP/2" or (
-            self._http2_enabled and not self._http1_enabled
-        ):
-            from .http2 import AsyncHTTP2Connection
-
-            self._is_http2 = True
-            self.connection = AsyncHTTP2Connection(
-                socket=socket,
-                keepalive_expiry=self._keepalive_expiry,
-                backend=self._backend,
-            )
-        else:
-            self._is_http11 = True
-            self.connection = AsyncHTTP11Connection(
-                socket=socket, keepalive_expiry=self._keepalive_expiry
-            )
+                async with Trace("retry", logger, request, kwargs) as trace:
+                    await self._network_backend.sleep(delay)
 
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> None:
-        if self.connection is not None:
-            logger.trace("start_tls hostname=%r timeout=%r", hostname, timeout)
-            self.socket = await self.connection.start_tls(
-                hostname, ssl_context, timeout
-            )
-            logger.trace("start_tls complete hostname=%r timeout=%r", hostname, timeout)
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
 
     async def aclose(self) -> None:
-        async with self.request_lock:
-            if self.connection is not None:
-                await self.connection.aclose()
+        if self._connection is not None:
+            async with Trace("close", logger, None, {}):
+                await self._connection.aclose()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTPConnection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection_pool.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection_pool.py
index 0902ac2..018b0ba 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection_pool.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/connection_pool.py
@@ -1,362 +1,380 @@
-import warnings
-from ssl import SSLContext
-from typing import (
-    AsyncIterator,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
-
-from .._backends.auto import AsyncBackend, AsyncLock, AsyncSemaphore
-from .._backends.base import lookup_async_backend
-from .._exceptions import LocalProtocolError, PoolTimeout, UnsupportedProtocol
-from .._threadlock import ThreadLock
-from .._types import URL, Headers, Origin, TimeoutDict
-from .._utils import get_logger, origin_to_url_string, url_to_origin
-from .base import AsyncByteStream, AsyncHTTPTransport, NewConnectionRequired
+import ssl
+import sys
+from types import TracebackType
+from typing import AsyncIterable, AsyncIterator, Iterable, List, Optional, Type
+
+from .._backends.auto import AutoBackend
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncEvent, AsyncShieldCancellation, AsyncThreadLock
 from .connection import AsyncHTTPConnection
+from .interfaces import AsyncConnectionInterface, AsyncRequestInterface
 
-logger = get_logger(__name__)
 
+class AsyncPoolRequest:
+    def __init__(self, request: Request) -> None:
+        self.request = request
+        self.connection: Optional[AsyncConnectionInterface] = None
+        self._connection_acquired = AsyncEvent()
 
-class NullSemaphore(AsyncSemaphore):
-    def __init__(self) -> None:
-        pass
-
-    async def acquire(self, timeout: float = None) -> None:
-        return
-
-    async def release(self) -> None:
-        return
-
-
-class ResponseByteStream(AsyncByteStream):
-    def __init__(
-        self,
-        stream: AsyncByteStream,
-        connection: AsyncHTTPConnection,
-        callback: Callable,
+    def assign_to_connection(
+        self, connection: Optional[AsyncConnectionInterface]
     ) -> None:
-        """
-        A wrapper around the response stream that we return from
-        `.handle_async_request()`.
-
-        Ensures that when `stream.aclose()` is called, the connection pool
-        is notified via a callback.
-        """
-        self.stream = stream
         self.connection = connection
-        self.callback = callback
+        self._connection_acquired.set()
 
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        async for chunk in self.stream:
-            yield chunk
+    def clear_connection(self) -> None:
+        self.connection = None
+        self._connection_acquired = AsyncEvent()
 
-    async def aclose(self) -> None:
-        try:
-            # Call the underlying stream close callback.
-            # This will be a call to `AsyncHTTP11Connection._response_closed()`
-            # or `AsyncHTTP2Stream._response_closed()`.
-            await self.stream.aclose()
-        finally:
-            # Call the connection pool close callback.
-            # This will be a call to `AsyncConnectionPool._response_closed()`.
-            await self.callback(self.connection)
+    async def wait_for_connection(
+        self, timeout: Optional[float] = None
+    ) -> AsyncConnectionInterface:
+        if self.connection is None:
+            await self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
 
+    def is_queued(self) -> bool:
+        return self.connection is None
 
-class AsyncConnectionPool(AsyncHTTPTransport):
+
+class AsyncConnectionPool(AsyncRequestInterface):
     """
     A connection pool for making HTTP requests.
-
-    Parameters
-    ----------
-    ssl_context:
-        An SSL context to use for verifying connections.
-    max_connections:
-        The maximum number of concurrent connections to allow.
-    max_keepalive_connections:
-        The maximum number of connections to allow before closing keep-alive
-        connections.
-    keepalive_expiry:
-        The maximum time to allow before closing a keep-alive connection.
-    http1:
-        Enable/Disable HTTP/1.1 support. Defaults to True.
-    http2:
-        Enable/Disable HTTP/2 support. Defaults to False.
-    uds:
-        Path to a Unix Domain Socket to use instead of TCP sockets.
-    local_address:
-        Local address to connect from. Can also be used to connect using a particular
-        address family. Using ``local_address="0.0.0.0"`` will connect using an
-        ``AF_INET`` address (IPv4), while using ``local_address="::"`` will connect
-        using an ``AF_INET6`` address (IPv6).
-    retries:
-        The maximum number of retries when trying to establish a connection.
-    backend:
-        A name indicating which concurrency backend to use.
     """
 
     def __init__(
         self,
-        ssl_context: SSLContext = None,
-        max_connections: int = None,
-        max_keepalive_connections: int = None,
-        keepalive_expiry: float = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
         http1: bool = True,
         http2: bool = False,
-        uds: str = None,
-        local_address: str = None,
         retries: int = 0,
-        max_keepalive: int = None,
-        backend: Union[AsyncBackend, str] = "auto",
-    ):
-        if max_keepalive is not None:
-            warnings.warn(
-                "'max_keepalive' is deprecated. Use 'max_keepalive_connections'.",
-                DeprecationWarning,
-            )
-            max_keepalive_connections = max_keepalive
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+            socket_options: Socket options that have to be included
+             in the TCP socket when the connection was established.
+        """
+        self._ssl_context = ssl_context
 
-        if isinstance(backend, str):
-            backend = lookup_async_backend(backend)
+        self._max_connections = (
+            sys.maxsize if max_connections is None else max_connections
+        )
+        self._max_keepalive_connections = (
+            sys.maxsize
+            if max_keepalive_connections is None
+            else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(
+            self._max_connections, self._max_keepalive_connections
+        )
 
-        self._ssl_context = SSLContext() if ssl_context is None else ssl_context
-        self._max_connections = max_connections
-        self._max_keepalive_connections = max_keepalive_connections
         self._keepalive_expiry = keepalive_expiry
         self._http1 = http1
         self._http2 = http2
-        self._uds = uds
-        self._local_address = local_address
         self._retries = retries
-        self._connections: Dict[Origin, Set[AsyncHTTPConnection]] = {}
-        self._thread_lock = ThreadLock()
-        self._backend = backend
-        self._next_keepalive_check = 0.0
-
-        if not (http1 or http2):
-            raise ValueError("Either http1 or http2 must be True.")
-
-        if http2:
-            try:
-                import h2  # noqa: F401
-            except ImportError:
-                raise ImportError(
-                    "Attempted to use http2=True, but the 'h2' "
-                    "package is not installed. Use 'pip install httpcore[http2]'."
-                )
+        self._local_address = local_address
+        self._uds = uds
 
-    @property
-    def _connection_semaphore(self) -> AsyncSemaphore:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_internal_semaphore"):
-            if self._max_connections is not None:
-                self._internal_semaphore = self._backend.create_semaphore(
-                    self._max_connections, exc_class=PoolTimeout
-                )
-            else:
-                self._internal_semaphore = NullSemaphore()
-
-        return self._internal_semaphore
+        self._network_backend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+        self._socket_options = socket_options
 
-    @property
-    def _connection_acquiry_lock(self) -> AsyncLock:
-        if not hasattr(self, "_internal_connection_acquiry_lock"):
-            self._internal_connection_acquiry_lock = self._backend.create_lock()
-        return self._internal_connection_acquiry_lock
+        # The mutable state on a connection pool is the queue of incoming requests,
+        # and the set of connections that are servicing those requests.
+        self._connections: List[AsyncConnectionInterface] = []
+        self._requests: List[AsyncPoolRequest] = []
 
-    def _create_connection(
-        self,
-        origin: Tuple[bytes, bytes, int],
-    ) -> AsyncHTTPConnection:
+        # We only mutate the state of the connection pool within an 'optional_thread_lock'
+        # context. This holds a threading lock unless we're running in async mode,
+        # in which case it is a no-op.
+        self._optional_thread_lock = AsyncThreadLock()
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
         return AsyncHTTPConnection(
             origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
             http1=self._http1,
             http2=self._http2,
-            keepalive_expiry=self._keepalive_expiry,
-            uds=self._uds,
-            ssl_context=self._ssl_context,
-            local_address=self._local_address,
             retries=self._retries,
-            backend=self._backend,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+            socket_options=self._socket_options,
         )
 
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        if not url[0]:
+    @property
+    def connections(self) -> List[AsyncConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <AsyncHTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._connections)
+
+    async def handle_async_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
             raise UnsupportedProtocol(
-                "Request URL missing either an 'http://' or 'https://' protocol."
+                "Request URL is missing an 'http://' or 'https://' protocol."
             )
-
-        if url[0] not in (b"http", b"https"):
-            protocol = url[0].decode("ascii")
+        if scheme not in ("http", "https", "ws", "wss"):
             raise UnsupportedProtocol(
-                f"Request URL has an unsupported protocol '{protocol}://'."
+                f"Request URL has an unsupported protocol '{scheme}://'."
             )
 
-        if not url[1]:
-            raise LocalProtocolError("Missing hostname in URL.")
-
-        origin = url_to_origin(url)
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
 
-        await self._keepalive_sweep()
+        with self._optional_thread_lock:
+            # Add the incoming request to our request queue.
+            pool_request = AsyncPoolRequest(request)
+            self._requests.append(pool_request)
 
-        connection: Optional[AsyncHTTPConnection] = None
-        while connection is None:
-            async with self._connection_acquiry_lock:
-                # We get-or-create a connection as an atomic operation, to ensure
-                # that HTTP/2 requests issued in close concurrency will end up
-                # on the same connection.
-                logger.trace("get_connection_from_pool=%r", origin)
-                connection = await self._get_connection_from_pool(origin)
-
-                if connection is None:
-                    connection = self._create_connection(origin=origin)
-                    logger.trace("created connection=%r", connection)
-                    await self._add_to_pool(connection, timeout=timeout)
+        try:
+            while True:
+                with self._optional_thread_lock:
+                    # Assign incoming requests to available connections,
+                    # closing or creating new connections as required.
+                    closing = self._assign_requests_to_connections()
+                await self._close_connections(closing)
+
+                # Wait until this request has an assigned connection.
+                connection = await pool_request.wait_for_connection(timeout=timeout)
+
+                try:
+                    # Send the request on the assigned connection.
+                    response = await connection.handle_async_request(
+                        pool_request.request
+                    )
+                except ConnectionNotAvailable:
+                    # In some cases a connection may initially be available to
+                    # handle a request, but then become unavailable.
+                    #
+                    # In this case we clear the connection and try again.
+                    pool_request.clear_connection()
                 else:
-                    logger.trace("reuse connection=%r", connection)
-
-            try:
-                response = await connection.handle_async_request(
-                    method, url, headers=headers, stream=stream, extensions=extensions
-                )
-            except NewConnectionRequired:
-                connection = None
-            except BaseException:  # noqa: PIE786
-                # See https://github.com/encode/httpcore/pull/305 for motivation
-                # behind catching 'BaseException' rather than 'Exception' here.
-                logger.trace("remove from pool connection=%r", connection)
-                await self._remove_from_pool(connection)
-                raise
-
-        status_code, headers, stream, extensions = response
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
+                    break  # pragma: nocover
+
+        except BaseException as exc:
+            with self._optional_thread_lock:
+                # For any exception or cancellation we remove the request from
+                # the queue, and then re-assign requests to connections.
+                self._requests.remove(pool_request)
+                closing = self._assign_requests_to_connections()
+
+            await self._close_connections(closing)
+            raise exc from None
+
+        # Return the response. Note that in this case we still have to manage
+        # the point at which the response is closed.
+        assert isinstance(response.stream, AsyncIterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=PoolByteStream(
+                stream=response.stream, pool_request=pool_request, pool=self
+            ),
+            extensions=response.extensions,
         )
-        return status_code, headers, wrapped_stream, extensions
-
-    async def _get_connection_from_pool(
-        self, origin: Origin
-    ) -> Optional[AsyncHTTPConnection]:
-        # Determine expired keep alive connections on this origin.
-        reuse_connection = None
-        connections_to_close = set()
-
-        for connection in self._connections_for_origin(origin):
-            if connection.should_close():
-                connections_to_close.add(connection)
-                await self._remove_from_pool(connection)
-            elif connection.is_available():
-                reuse_connection = connection
-
-        # Close any dropped connections.
-        for connection in connections_to_close:
-            await connection.aclose()
-
-        return reuse_connection
-
-    async def _response_closed(self, connection: AsyncHTTPConnection) -> None:
-        remove_from_pool = False
-        close_connection = False
-
-        if connection.is_closed():
-            remove_from_pool = True
-        elif connection.is_idle():
-            num_connections = len(self._get_all_connections())
-            if (
-                self._max_keepalive_connections is not None
-                and num_connections > self._max_keepalive_connections
-            ):
-                remove_from_pool = True
-                close_connection = True
 
-        if remove_from_pool:
-            await self._remove_from_pool(connection)
+    def _assign_requests_to_connections(self) -> List[AsyncConnectionInterface]:
+        """
+        Manage the state of the connection pool, assigning incoming
+        requests to connections as available.
 
-        if close_connection:
-            await connection.aclose()
+        Called whenever a new request is added or removed from the pool.
 
-    async def _keepalive_sweep(self) -> None:
+        Any closing connections are returned, allowing the I/O for closing
+        those connections to be handled seperately.
         """
-        Remove any IDLE connections that have expired past their keep-alive time.
-        """
-        if self._keepalive_expiry is None:
-            return
+        closing_connections = []
+
+        # First we handle cleaning up any connections that are closed,
+        # have expired their keep-alive, or surplus idle connections.
+        for connection in list(self._connections):
+            if connection.is_closed():
+                # log: "removing closed connection"
+                self._connections.remove(connection)
+            elif connection.has_expired():
+                # log: "closing expired connection"
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+            elif (
+                connection.is_idle()
+                and len([connection.is_idle() for connection in self._connections])
+                > self._max_keepalive_connections
+            ):
+                # log: "closing idle connection"
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+
+        # Assign queued requests to connections.
+        queued_requests = [request for request in self._requests if request.is_queued()]
+        for pool_request in queued_requests:
+            origin = pool_request.request.url.origin
+            avilable_connections = [
+                connection
+                for connection in self._connections
+                if connection.can_handle_request(origin) and connection.is_available()
+            ]
+            idle_connections = [
+                connection for connection in self._connections if connection.is_idle()
+            ]
+
+            # There are three cases for how we may be able to handle the request:
+            #
+            # 1. There is an existing connection that can handle the request.
+            # 2. We can create a new connection to handle the request.
+            # 3. We can close an idle connection and then create a new connection
+            #    to handle the request.
+            if avilable_connections:
+                # log: "reusing existing connection"
+                connection = avilable_connections[0]
+                pool_request.assign_to_connection(connection)
+            elif len(self._connections) < self._max_connections:
+                # log: "creating new connection"
+                connection = self.create_connection(origin)
+                self._connections.append(connection)
+                pool_request.assign_to_connection(connection)
+            elif idle_connections:
+                # log: "closing idle connection"
+                connection = idle_connections[0]
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+                # log: "creating new connection"
+                connection = self.create_connection(origin)
+                self._connections.append(connection)
+                pool_request.assign_to_connection(connection)
+
+        return closing_connections
+
+    async def _close_connections(self, closing: List[AsyncConnectionInterface]) -> None:
+        # Close connections which have been removed from the pool.
+        with AsyncShieldCancellation():
+            for connection in closing:
+                await connection.aclose()
 
-        now = await self._backend.time()
-        if now < self._next_keepalive_check:
-            return
+    async def aclose(self) -> None:
+        # Explicitly close the connection pool.
+        # Clears all existing requests and connections.
+        with self._optional_thread_lock:
+            closing_connections = list(self._connections)
+            self._connections = []
+        await self._close_connections(closing_connections)
 
-        self._next_keepalive_check = now + min(1.0, self._keepalive_expiry)
-        connections_to_close = set()
+    async def __aenter__(self) -> "AsyncConnectionPool":
+        return self
 
-        for connection in self._get_all_connections():
-            if connection.should_close():
-                connections_to_close.add(connection)
-                await self._remove_from_pool(connection)
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        with self._optional_thread_lock:
+            request_is_queued = [request.is_queued() for request in self._requests]
+            connection_is_idle = [
+                connection.is_idle() for connection in self._connections
+            ]
+
+            num_active_requests = request_is_queued.count(False)
+            num_queued_requests = request_is_queued.count(True)
+            num_active_connections = connection_is_idle.count(False)
+            num_idle_connections = connection_is_idle.count(True)
+
+        requests_info = (
+            f"Requests: {num_active_requests} active, {num_queued_requests} queued"
+        )
+        connection_info = (
+            f"Connections: {num_active_connections} active, {num_idle_connections} idle"
+        )
 
-        for connection in connections_to_close:
-            await connection.aclose()
+        return f"<{class_name} [{requests_info} | {connection_info}]>"
 
-    async def _add_to_pool(
-        self, connection: AsyncHTTPConnection, timeout: TimeoutDict
+
+class PoolByteStream:
+    def __init__(
+        self,
+        stream: AsyncIterable[bytes],
+        pool_request: AsyncPoolRequest,
+        pool: AsyncConnectionPool,
     ) -> None:
-        logger.trace("adding connection to pool=%r", connection)
-        await self._connection_semaphore.acquire(timeout=timeout.get("pool", None))
-        async with self._thread_lock:
-            self._connections.setdefault(connection.origin, set())
-            self._connections[connection.origin].add(connection)
-
-    async def _remove_from_pool(self, connection: AsyncHTTPConnection) -> None:
-        logger.trace("removing connection from pool=%r", connection)
-        async with self._thread_lock:
-            if connection in self._connections.get(connection.origin, set()):
-                await self._connection_semaphore.release()
-                self._connections[connection.origin].remove(connection)
-                if not self._connections[connection.origin]:
-                    del self._connections[connection.origin]
-
-    def _connections_for_origin(self, origin: Origin) -> Set[AsyncHTTPConnection]:
-        return set(self._connections.get(origin, set()))
-
-    def _get_all_connections(self) -> Set[AsyncHTTPConnection]:
-        connections: Set[AsyncHTTPConnection] = set()
-        for connection_set in self._connections.values():
-            connections |= connection_set
-        return connections
+        self._stream = stream
+        self._pool_request = pool_request
+        self._pool = pool
+        self._closed = False
 
-    async def aclose(self) -> None:
-        connections = self._get_all_connections()
-        for connection in connections:
-            await self._remove_from_pool(connection)
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        try:
+            async for part in self._stream:
+                yield part
+        except BaseException as exc:
+            await self.aclose()
+            raise exc from None
 
-        # Close all connections
-        for connection in connections:
-            await connection.aclose()
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with AsyncShieldCancellation():
+                if hasattr(self._stream, "aclose"):
+                    await self._stream.aclose()
 
-    async def get_connection_info(self) -> Dict[str, List[str]]:
-        """
-        Returns a dict of origin URLs to a list of summary strings for each connection.
-        """
-        await self._keepalive_sweep()
+            with self._pool._optional_thread_lock:
+                self._pool._requests.remove(self._pool_request)
+                closing = self._pool._assign_requests_to_connections()
 
-        stats = {}
-        for origin, connections in self._connections.items():
-            stats[origin_to_url_string(origin)] = sorted(
-                [connection.info() for connection in connections]
-            )
-        return stats
+            await self._pool._close_connections(closing)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http.py
deleted file mode 100644
index 06270f0..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from ssl import SSLContext
-
-from .._backends.auto import AsyncSocketStream
-from .._types import TimeoutDict
-from .base import AsyncHTTPTransport
-
-
-class AsyncBaseHTTPConnection(AsyncHTTPTransport):
-    def info(self) -> str:
-        raise NotImplementedError()  # pragma: nocover
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> AsyncSocketStream:
-        """
-        Upgrade the underlying socket to TLS.
-        """
-        raise NotImplementedError()  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http11.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http11.py
index a265657..0493a92 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http11.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http11.py
@@ -1,194 +1,196 @@
 import enum
+import logging
+import ssl
 import time
-from ssl import SSLContext
-from typing import AsyncIterator, List, Optional, Tuple, Union, cast
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 
 import h11
 
-from .._backends.auto import AsyncSocketStream
-from .._bytestreams import AsyncIteratorByteStream
-from .._exceptions import LocalProtocolError, RemoteProtocolError, map_exceptions
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger
-from .base import AsyncByteStream, NewConnectionRequired
-from .http import AsyncBaseHTTPConnection
+from .._backends.base import AsyncNetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    WriteError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock, AsyncShieldCancellation
+from .._trace import Trace
+from .interfaces import AsyncConnectionInterface
 
-H11Event = Union[
+logger = logging.getLogger("httpcore.http11")
+
+
+# A subset of `h11.Event` types supported by `_send_event`
+H11SendEvent = Union[
     h11.Request,
-    h11.Response,
-    h11.InformationalResponse,
     h11.Data,
     h11.EndOfMessage,
-    h11.ConnectionClosed,
 ]
 
 
-class ConnectionState(enum.IntEnum):
+class HTTPConnectionState(enum.IntEnum):
     NEW = 0
     ACTIVE = 1
     IDLE = 2
     CLOSED = 3
 
 
-logger = get_logger(__name__)
-
-
-class AsyncHTTP11Connection(AsyncBaseHTTPConnection):
+class AsyncHTTP11Connection(AsyncConnectionInterface):
     READ_NUM_BYTES = 64 * 1024
+    MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024
 
-    def __init__(self, socket: AsyncSocketStream, keepalive_expiry: float = None):
-        self.socket = socket
-
+    def __init__(
+        self,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: Optional[float] = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
         self._keepalive_expiry: Optional[float] = keepalive_expiry
-        self._should_expire_at: Optional[float] = None
-        self._h11_state = h11.Connection(our_role=h11.CLIENT)
-        self._state = ConnectionState.NEW
-
-    def __repr__(self) -> str:
-        return f"<AsyncHTTP11Connection [{self._state.name}]>"
-
-    def _now(self) -> float:
-        return time.monotonic()
-
-    def _server_disconnected(self) -> bool:
-        """
-        Return True if the connection is idle, and the underlying socket is readable.
-        The only valid state the socket can be readable here is when the b""
-        EOF marker is about to be returned, indicating a server disconnect.
-        """
-        return self._state == ConnectionState.IDLE and self.socket.is_readable()
-
-    def _keepalive_expired(self) -> bool:
-        """
-        Return True if the connection is idle, and has passed it's keepalive
-        expiry time.
-        """
-        return (
-            self._state == ConnectionState.IDLE
-            and self._should_expire_at is not None
-            and self._now() >= self._should_expire_at
+        self._expire_at: Optional[float] = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = AsyncLock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(
+            our_role=h11.CLIENT,
+            max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE,
         )
 
-    def info(self) -> str:
-        return f"HTTP/1.1, {self._state.name}"
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        """
-        return self._server_disconnected() or self._keepalive_expired()
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        return self._state == ConnectionState.IDLE
-
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        return self._state == ConnectionState.CLOSED
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            try:
+                async with Trace(
+                    "send_request_headers", logger, request, kwargs
+                ) as trace:
+                    await self._send_request_headers(**kwargs)
+                async with Trace("send_request_body", logger, request, kwargs) as trace:
+                    await self._send_request_body(**kwargs)
+            except WriteError:
+                # If we get a write error while we're writing the request,
+                # then we supress this error and move on to attempting to
+                # read the response. Servers can sometimes close the request
+                # pre-emptively and then respond with a well formed HTTP
+                # error response.
+                pass
+
+            async with Trace(
+                "receive_response_headers", logger, request, kwargs
+            ) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                    trailing_data,
+                ) = await self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            network_stream = self._network_stream
+
+            # CONNECT or Upgrade request
+            if (status == 101) or (
+                (request.method == b"CONNECT") and (200 <= status < 300)
+            ):
+                network_stream = AsyncHTTP11UpgradeStream(network_stream, trailing_data)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": network_stream,
+                },
+            )
+        except BaseException as exc:
+            with AsyncShieldCancellation():
+                async with Trace("response_closed", logger, request) as trace:
+                    await self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    async def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
 
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        """
-        return self._state == ConnectionState.IDLE
+        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        await self._send_event(event, timeout=timeout)
+
+    async def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, AsyncIterable)
+        async for chunk in request.stream:
+            event = h11.Data(data=chunk)
+            await self._send_event(event, timeout=timeout)
 
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        """
-        Send a single HTTP/1.1 request.
-
-        Note that there is no kind of task/thread locking at this layer of interface.
-        Dealing with locking for concurrency is handled by the `AsyncHTTPConnection`.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        if self._state in (ConnectionState.NEW, ConnectionState.IDLE):
-            self._state = ConnectionState.ACTIVE
-            self._should_expire_at = None
-        else:
-            raise NewConnectionRequired()
-
-        await self._send_request(method, url, headers, timeout)
-        await self._send_request_body(stream, timeout)
-        (
-            http_version,
-            status_code,
-            reason_phrase,
-            headers,
-        ) = await self._receive_response(timeout)
-        response_stream = AsyncIteratorByteStream(
-            aiterator=self._receive_response_data(timeout),
-            aclose_func=self._response_closed,
-        )
-        extensions = {
-            "http_version": http_version,
-            "reason_phrase": reason_phrase,
-        }
-        return (status_code, headers, response_stream, extensions)
+        await self._send_event(h11.EndOfMessage(), timeout=timeout)
 
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> AsyncSocketStream:
-        timeout = {} if timeout is None else timeout
-        self.socket = await self.socket.start_tls(hostname, ssl_context, timeout)
-        return self.socket
-
-    async def _send_request(
-        self, method: bytes, url: URL, headers: Headers, timeout: TimeoutDict
+    async def _send_event(
+        self, event: h11.Event, timeout: Optional[float] = None
     ) -> None:
-        """
-        Send the request line and headers.
-        """
-        logger.trace("send_request method=%r url=%r headers=%s", method, url, headers)
-        _scheme, _host, _port, target = url
-        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
-            event = h11.Request(method=method, target=target, headers=headers)
-        await self._send_event(event, timeout)
+        bytes_to_send = self._h11_state.send(event)
+        if bytes_to_send is not None:
+            await self._network_stream.write(bytes_to_send, timeout=timeout)
 
-    async def _send_request_body(
-        self, stream: AsyncByteStream, timeout: TimeoutDict
-    ) -> None:
-        """
-        Send the request body.
-        """
-        # Send the request body.
-        async for chunk in stream:
-            logger.trace("send_data=Data(<%d bytes>)", len(chunk))
-            event = h11.Data(data=chunk)
-            await self._send_event(event, timeout)
+    # Receiving the response...
 
-        # Finalize sending the request.
-        event = h11.EndOfMessage()
-        await self._send_event(event, timeout)
+    async def _receive_response_headers(
+        self, request: Request
+    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]], bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
 
-    async def _send_event(self, event: H11Event, timeout: TimeoutDict) -> None:
-        """
-        Send a single `h11` event to the network, waiting for the data to
-        drain before returning.
-        """
-        bytes_to_send = self._h11_state.send(event)
-        await self.socket.write(bytes_to_send, timeout)
-
-    async def _receive_response(
-        self, timeout: TimeoutDict
-    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]]]:
-        """
-        Read the response status and headers from the network.
-        """
         while True:
-            event = await self._receive_event(timeout)
+            event = await self._receive_event(timeout=timeout)
             if isinstance(event, h11.Response):
                 break
+            if (
+                isinstance(event, h11.InformationalResponse)
+                and event.status_code == 101
+            ):
+                break
 
         http_version = b"HTTP/" + event.http_version
 
@@ -196,33 +198,32 @@ async def _receive_response(
         # raw header casing, rather than the enforced lowercase headers.
         headers = event.headers.raw_items()
 
-        return http_version, event.status_code, event.reason, headers
+        trailing_data, _ = self._h11_state.trailing_data
+
+        return http_version, event.status_code, event.reason, headers, trailing_data
+
+    async def _receive_response_body(self, request: Request) -> AsyncIterator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
 
-    async def _receive_response_data(
-        self, timeout: TimeoutDict
-    ) -> AsyncIterator[bytes]:
-        """
-        Read the response data from the network.
-        """
         while True:
-            event = await self._receive_event(timeout)
+            event = await self._receive_event(timeout=timeout)
             if isinstance(event, h11.Data):
-                logger.trace("receive_event=Data(<%d bytes>)", len(event.data))
                 yield bytes(event.data)
             elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
-                logger.trace("receive_event=%r", event)
                 break
 
-    async def _receive_event(self, timeout: TimeoutDict) -> H11Event:
-        """
-        Read a single `h11` event, reading more data from the network if needed.
-        """
+    async def _receive_event(
+        self, timeout: Optional[float] = None
+    ) -> Union[h11.Event, Type[h11.PAUSED]]:
         while True:
             with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
                 event = self._h11_state.next_event()
 
             if event is h11.NEED_DATA:
-                data = await self.socket.read(self.READ_NUM_BYTES, timeout)
+                data = await self._network_stream.read(
+                    self.READ_NUM_BYTES, timeout=timeout
+                )
 
                 # If we feed this case through h11 we'll raise an exception like:
                 #
@@ -230,40 +231,156 @@ async def _receive_event(self, timeout: TimeoutDict) -> H11Event:
                 #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
                 #
                 # Which is accurate, but not very informative from an end-user
-                # perspective. Instead we handle messaging for this case distinctly.
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
                 if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
                     msg = "Server disconnected without sending a response."
                     raise RemoteProtocolError(msg)
 
                 self._h11_state.receive_data(data)
             else:
-                assert event is not h11.NEED_DATA
-                break
-        return event
+                # mypy fails to narrow the type in the above if statement above
+                return event  # type: ignore[return-value]
 
     async def _response_closed(self) -> None:
-        logger.trace(
-            "response_closed our_state=%r their_state=%r",
-            self._h11_state.our_state,
-            self._h11_state.their_state,
+        async with self._state_lock:
+            if (
+                self._h11_state.our_state is h11.DONE
+                and self._h11_state.their_state is h11.DONE
+            ):
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                await self.aclose()
+
+    # Once the connection is no longer required...
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # The AsyncConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        keepalive_expired = self._expire_at is not None and now > self._expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = (
+            self._state == HTTPConnectionState.IDLE
+            and self._network_stream.get_extra_info("is_readable")
         )
-        if (
-            self._h11_state.our_state is h11.DONE
-            and self._h11_state.their_state is h11.DONE
-        ):
-            self._h11_state.start_next_cycle()
-            self._state = ConnectionState.IDLE
-            if self._keepalive_expiry is not None:
-                self._should_expire_at = self._now() + self._keepalive_expiry
-        else:
-            await self.aclose()
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/1.1, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTP11Connection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: AsyncHTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            async with Trace("receive_response_body", logger, self._request, kwargs):
+                async for chunk in self._connection._receive_response_body(**kwargs):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with AsyncShieldCancellation():
+                await self.aclose()
+            raise exc
 
     async def aclose(self) -> None:
-        if self._state != ConnectionState.CLOSED:
-            self._state = ConnectionState.CLOSED
+        if not self._closed:
+            self._closed = True
+            async with Trace("response_closed", logger, self._request):
+                await self._connection._response_closed()
+
+
+class AsyncHTTP11UpgradeStream(AsyncNetworkStream):
+    def __init__(self, stream: AsyncNetworkStream, leading_data: bytes) -> None:
+        self._stream = stream
+        self._leading_data = leading_data
+
+    async def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if self._leading_data:
+            buffer = self._leading_data[:max_bytes]
+            self._leading_data = self._leading_data[max_bytes:]
+            return buffer
+        else:
+            return await self._stream.read(max_bytes, timeout)
 
-            if self._h11_state.our_state is h11.MUST_CLOSE:
-                event = h11.ConnectionClosed()
-                self._h11_state.send(event)
+    async def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        await self._stream.write(buffer, timeout)
 
-            await self.socket.aclose()
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        return await self._stream.start_tls(ssl_context, server_hostname, timeout)
+
+    def get_extra_info(self, info: str) -> Any:
+        return self._stream.get_extra_info(info)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http2.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http2.py
index 35a4e09..8dc776f 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http2.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http2.py
@@ -1,175 +1,190 @@
 import enum
+import logging
 import time
-from ssl import SSLContext
-from typing import AsyncIterator, Dict, List, Optional, Tuple, cast
+import types
+import typing
 
+import h2.config
 import h2.connection
 import h2.events
-from h2.config import H2Configuration
-from h2.exceptions import NoAvailableStreamIDError
-from h2.settings import SettingCodes, Settings
+import h2.exceptions
+import h2.settings
 
-from .._backends.auto import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
-from .._bytestreams import AsyncIteratorByteStream
-from .._exceptions import LocalProtocolError, PoolTimeout, RemoteProtocolError
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger
-from .base import AsyncByteStream, NewConnectionRequired
-from .http import AsyncBaseHTTPConnection
+from .._backends.base import AsyncNetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock, AsyncSemaphore, AsyncShieldCancellation
+from .._trace import Trace
+from .interfaces import AsyncConnectionInterface
 
-logger = get_logger(__name__)
+logger = logging.getLogger("httpcore.http2")
 
 
-class ConnectionState(enum.IntEnum):
-    IDLE = 0
+def has_body_headers(request: Request) -> bool:
+    return any(
+        k.lower() == b"content-length" or k.lower() == b"transfer-encoding"
+        for k, v in request.headers
+    )
+
+
+class HTTPConnectionState(enum.IntEnum):
     ACTIVE = 1
-    CLOSED = 2
+    IDLE = 2
+    CLOSED = 3
 
 
-class AsyncHTTP2Connection(AsyncBaseHTTPConnection):
+class AsyncHTTP2Connection(AsyncConnectionInterface):
     READ_NUM_BYTES = 64 * 1024
-    CONFIG = H2Configuration(validate_inbound_headers=False)
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
 
     def __init__(
         self,
-        socket: AsyncSocketStream,
-        backend: AsyncBackend,
-        keepalive_expiry: float = None,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: typing.Optional[float] = None,
     ):
-        self.socket = socket
-
-        self._backend = backend
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: typing.Optional[float] = keepalive_expiry
         self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
-
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: typing.Optional[float] = None
+        self._request_count = 0
+        self._init_lock = AsyncLock()
+        self._state_lock = AsyncLock()
+        self._read_lock = AsyncLock()
+        self._write_lock = AsyncLock()
         self._sent_connection_init = False
-        self._streams: Dict[int, AsyncHTTP2Stream] = {}
-        self._events: Dict[int, List[h2.events.Event]] = {}
-
-        self._keepalive_expiry: Optional[float] = keepalive_expiry
-        self._should_expire_at: Optional[float] = None
-        self._state = ConnectionState.ACTIVE
-        self._exhausted_available_stream_ids = False
-
-    def __repr__(self) -> str:
-        return f"<AsyncHTTP2Connection [{self._state}]>"
-
-    def info(self) -> str:
-        return f"HTTP/2, {self._state.name}, {len(self._streams)} streams"
-
-    def _now(self) -> float:
-        return time.monotonic()
+        self._used_all_stream_ids = False
+        self._connection_error = False
+
+        # Mapping from stream ID to response stream events.
+        self._events: typing.Dict[
+            int,
+            typing.Union[
+                h2.events.ResponseReceived,
+                h2.events.DataReceived,
+                h2.events.StreamEnded,
+                h2.events.StreamReset,
+            ],
+        ] = {}
+
+        # Connection terminated events are stored as state since
+        # we need to handle them for all streams.
+        self._connection_terminated: typing.Optional[
+            h2.events.ConnectionTerminated
+        ] = None
+
+        self._read_exception: typing.Optional[Exception] = None
+        self._write_exception: typing.Optional[Exception] = None
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
 
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is currently idle, and the keepalive
-        timeout has passed.
-        """
-        return (
-            self._state == ConnectionState.IDLE
-            and self._should_expire_at is not None
-            and self._now() >= self._should_expire_at
-        )
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
 
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        return self._state == ConnectionState.IDLE
+        async with self._init_lock:
+            if not self._sent_connection_init:
+                try:
+                    kwargs = {"request": request}
+                    async with Trace("send_connection_init", logger, request, kwargs):
+                        await self._send_connection_init(**kwargs)
+                except BaseException as exc:
+                    with AsyncShieldCancellation():
+                        await self.aclose()
+                    raise exc
 
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        return self._state == ConnectionState.CLOSED
+                self._sent_connection_init = True
 
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        This occurs when any of the following occur:
-
-        * The connection has not yet been opened, and HTTP/2 support is enabled.
-          We don't *know* at this point if we'll end up on an HTTP/2 connection or
-          not, but we *might* do, so we indicate availability.
-        * The connection has been opened, and is currently idle.
-        * The connection is open, and is an HTTP/2 connection. The connection must
-          also not have exhausted the maximum total number of stream IDs.
-        """
-        return (
-            self._state != ConnectionState.CLOSED
-            and not self._exhausted_available_stream_ids
-        )
+                # Initially start with just 1 until the remote server provides
+                # its max_concurrent_streams value
+                self._max_streams = 1
 
-    @property
-    def init_lock(self) -> AsyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_initialization_lock"):
-            self._initialization_lock = self._backend.create_lock()
-        return self._initialization_lock
-
-    @property
-    def read_lock(self) -> AsyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_read_lock"):
-            self._read_lock = self._backend.create_lock()
-        return self._read_lock
-
-    @property
-    def max_streams_semaphore(self) -> AsyncSemaphore:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_max_streams_semaphore"):
-            max_streams = self._h2_state.local_settings.max_concurrent_streams
-            self._max_streams_semaphore = self._backend.create_semaphore(
-                max_streams, exc_class=PoolTimeout
-            )
-        return self._max_streams_semaphore
+                local_settings_max_streams = (
+                    self._h2_state.local_settings.max_concurrent_streams
+                )
+                self._max_streams_semaphore = AsyncSemaphore(local_settings_max_streams)
 
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> AsyncSocketStream:
-        raise NotImplementedError("TLS upgrade not supported on HTTP/2 connections.")
+                for _ in range(local_settings_max_streams - self._max_streams):
+                    await self._max_streams_semaphore.acquire()
 
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        async with self.init_lock:
-            if not self._sent_connection_init:
-                # The very first stream is responsible for initiating the connection.
-                self._state = ConnectionState.ACTIVE
-                await self.send_connection_init(timeout)
-                self._sent_connection_init = True
+        await self._max_streams_semaphore.acquire()
 
-        await self.max_streams_semaphore.acquire()
         try:
-            try:
-                stream_id = self._h2_state.get_next_available_stream_id()
-            except NoAvailableStreamIDError:
-                self._exhausted_available_stream_ids = True
-                raise NewConnectionRequired()
-            else:
-                self._state = ConnectionState.ACTIVE
-                self._should_expire_at = None
-
-            h2_stream = AsyncHTTP2Stream(stream_id=stream_id, connection=self)
-            self._streams[stream_id] = h2_stream
+            stream_id = self._h2_state.get_next_available_stream_id()
             self._events[stream_id] = []
-            return await h2_stream.handle_async_request(
-                method, url, headers, stream, extensions
-            )
-        except Exception:  # noqa: PIE786
-            await self.max_streams_semaphore.release()
-            raise
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: nocover
+            self._used_all_stream_ids = True
+            self._request_count -= 1
+            raise ConnectionNotAvailable()
 
-    async def send_connection_init(self, timeout: TimeoutDict) -> None:
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            async with Trace("send_request_headers", logger, request, kwargs):
+                await self._send_request_headers(request=request, stream_id=stream_id)
+            async with Trace("send_request_body", logger, request, kwargs):
+                await self._send_request_body(request=request, stream_id=stream_id)
+            async with Trace(
+                "receive_response_headers", logger, request, kwargs
+            ) as trace:
+                status, headers = await self._receive_response(
+                    request=request, stream_id=stream_id
+                )
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={
+                    "http_version": b"HTTP/2",
+                    "network_stream": self._network_stream,
+                    "stream_id": stream_id,
+                },
+            )
+        except BaseException as exc:  # noqa: PIE786
+            with AsyncShieldCancellation():
+                kwargs = {"stream_id": stream_id}
+                async with Trace("response_closed", logger, request, kwargs):
+                    await self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_terminated:  # pragma: nocover
+                    raise RemoteProtocolError(self._connection_terminated)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: nocover
+
+            raise exc
+
+    async def _send_connection_init(self, request: Request) -> None:
         """
         The HTTP/2 connection requires some initial setup before we can start
         using individual request/response streams on it.
@@ -177,15 +192,15 @@ async def send_connection_init(self, timeout: TimeoutDict) -> None:
         # Need to set these manually here instead of manipulating via
         # __setitem__() otherwise the H2Connection will emit SettingsUpdate
         # frames in addition to sending the undesired defaults.
-        self._h2_state.local_settings = Settings(
+        self._h2_state.local_settings = h2.settings.Settings(
             client=True,
             initial_values={
                 # Disable PUSH_PROMISE frames from the server since we don't do anything
                 # with them for now.  Maybe when we support caching?
-                SettingCodes.ENABLE_PUSH: 0,
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
                 # These two are taken from h2 for safe defaults
-                SettingCodes.MAX_CONCURRENT_STREAMS: 100,
-                SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
             },
         )
 
@@ -196,227 +211,85 @@ async def send_connection_init(self, timeout: TimeoutDict) -> None:
             h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL
         ]
 
-        logger.trace("initiate_connection=%r", self)
         self._h2_state.initiate_connection()
-        self._h2_state.increment_flow_control_window(2 ** 24)
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    def is_socket_readable(self) -> bool:
-        return self.socket.is_readable()
-
-    async def aclose(self) -> None:
-        logger.trace("close_connection=%r", self)
-        if self._state != ConnectionState.CLOSED:
-            self._state = ConnectionState.CLOSED
-
-            await self.socket.aclose()
-
-    async def wait_for_outgoing_flow(self, stream_id: int, timeout: TimeoutDict) -> int:
-        """
-        Returns the maximum allowable outgoing flow for a given stream.
-        If the allowable flow is zero, then waits on the network until
-        WindowUpdated frames have increased the flow rate.
-        https://tools.ietf.org/html/rfc7540#section-6.9
-        """
-        local_flow = self._h2_state.local_flow_control_window(stream_id)
-        connection_flow = self._h2_state.max_outbound_frame_size
-        flow = min(local_flow, connection_flow)
-        while flow == 0:
-            await self.receive_events(timeout)
-            local_flow = self._h2_state.local_flow_control_window(stream_id)
-            connection_flow = self._h2_state.max_outbound_frame_size
-            flow = min(local_flow, connection_flow)
-        return flow
+        self._h2_state.increment_flow_control_window(2**24)
+        await self._write_outgoing_data(request)
 
-    async def wait_for_event(
-        self, stream_id: int, timeout: TimeoutDict
-    ) -> h2.events.Event:
-        """
-        Returns the next event for a given stream.
-        If no events are available yet, then waits on the network until
-        an event is available.
-        """
-        async with self.read_lock:
-            while not self._events[stream_id]:
-                await self.receive_events(timeout)
-        return self._events[stream_id].pop(0)
+    # Sending the request...
 
-    async def receive_events(self, timeout: TimeoutDict) -> None:
+    async def _send_request_headers(self, request: Request, stream_id: int) -> None:
         """
-        Read some data from the network, and update the H2 state.
+        Send the request headers to a given stream ID.
         """
-        data = await self.socket.read(self.READ_NUM_BYTES, timeout)
-        if data == b"":
-            raise RemoteProtocolError("Server disconnected")
-
-        events = self._h2_state.receive_data(data)
-        for event in events:
-            event_stream_id = getattr(event, "stream_id", 0)
-            logger.trace("receive_event stream_id=%r event=%s", event_stream_id, event)
-
-            if hasattr(event, "error_code"):
-                raise RemoteProtocolError(event)
-
-            if event_stream_id in self._events:
-                self._events[event_stream_id].append(event)
-
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    async def send_headers(
-        self, stream_id: int, headers: Headers, end_stream: bool, timeout: TimeoutDict
-    ) -> None:
-        logger.trace("send_headers stream_id=%r headers=%r", stream_id, headers)
-        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
-        self._h2_state.increment_flow_control_window(2 ** 24, stream_id=stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    async def send_data(
-        self, stream_id: int, chunk: bytes, timeout: TimeoutDict
-    ) -> None:
-        logger.trace("send_data stream_id=%r chunk=%r", stream_id, chunk)
-        self._h2_state.send_data(stream_id, chunk)
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    async def end_stream(self, stream_id: int, timeout: TimeoutDict) -> None:
-        logger.trace("end_stream stream_id=%r", stream_id)
-        self._h2_state.end_stream(stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    async def acknowledge_received_data(
-        self, stream_id: int, amount: int, timeout: TimeoutDict
-    ) -> None:
-        self._h2_state.acknowledge_received_data(amount, stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        await self.socket.write(data_to_send, timeout)
-
-    async def close_stream(self, stream_id: int) -> None:
-        try:
-            logger.trace("close_stream stream_id=%r", stream_id)
-            del self._streams[stream_id]
-            del self._events[stream_id]
-
-            if not self._streams:
-                if self._state == ConnectionState.ACTIVE:
-                    if self._exhausted_available_stream_ids:
-                        await self.aclose()
-                    else:
-                        self._state = ConnectionState.IDLE
-                        if self._keepalive_expiry is not None:
-                            self._should_expire_at = (
-                                self._now() + self._keepalive_expiry
-                            )
-        finally:
-            await self.max_streams_semaphore.release()
-
-
-class AsyncHTTP2Stream:
-    def __init__(self, stream_id: int, connection: AsyncHTTP2Connection) -> None:
-        self.stream_id = stream_id
-        self.connection = connection
-
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        headers = [(k.lower(), v) for (k, v) in headers]
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        # Send the request.
-        seen_headers = set(key for key, value in headers)
-        has_body = (
-            b"content-length" in seen_headers or b"transfer-encoding" in seen_headers
-        )
-
-        await self.send_headers(method, url, headers, has_body, timeout)
-        if has_body:
-            await self.send_body(stream, timeout)
-
-        # Receive the response.
-        status_code, headers = await self.receive_response(timeout)
-        response_stream = AsyncIteratorByteStream(
-            aiterator=self.body_iter(timeout), aclose_func=self._response_closed
-        )
-
-        extensions = {
-            "http_version": b"HTTP/2",
-        }
-        return (status_code, headers, response_stream, extensions)
-
-    async def send_headers(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        has_body: bool,
-        timeout: TimeoutDict,
-    ) -> None:
-        scheme, hostname, port, path = url
+        end_stream = not has_body_headers(request)
 
         # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
         # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
         # HTTP/1.1 style headers, and map them appropriately if we end up on
         # an HTTP/2 connection.
-        authority = None
-
-        for k, v in headers:
-            if k == b"host":
-                authority = v
-                break
-
-        if authority is None:
-            # Mirror the same error we'd see with `h11`, so that the behaviour
-            # is consistent. Although we're dealing with an `:authority`
-            # pseudo-header by this point, from an end-user perspective the issue
-            # is that the outgoing request needed to include a `host` header.
-            raise LocalProtocolError("Missing mandatory Host: header")
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
 
         headers = [
-            (b":method", method),
+            (b":method", request.method),
             (b":authority", authority),
-            (b":scheme", scheme),
-            (b":path", path),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
         ] + [
-            (k, v)
-            for k, v in headers
-            if k
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
             not in (
                 b"host",
                 b"transfer-encoding",
             )
         ]
-        end_stream = not has_body
 
-        await self.connection.send_headers(self.stream_id, headers, end_stream, timeout)
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        await self._write_outgoing_data(request)
 
-    async def send_body(self, stream: AsyncByteStream, timeout: TimeoutDict) -> None:
-        async for data in stream:
-            while data:
-                max_flow = await self.connection.wait_for_outgoing_flow(
-                    self.stream_id, timeout
-                )
-                chunk_size = min(len(data), max_flow)
-                chunk, data = data[:chunk_size], data[chunk_size:]
-                await self.connection.send_data(self.stream_id, chunk, timeout)
+    async def _send_request_body(self, request: Request, stream_id: int) -> None:
+        """
+        Iterate over the request body sending it to a given stream ID.
+        """
+        if not has_body_headers(request):
+            return
 
-        await self.connection.end_stream(self.stream_id, timeout)
+        assert isinstance(request.stream, typing.AsyncIterable)
+        async for data in request.stream:
+            await self._send_stream_data(request, stream_id, data)
+        await self._send_end_stream(request, stream_id)
 
-    async def receive_response(
-        self, timeout: TimeoutDict
-    ) -> Tuple[int, List[Tuple[bytes, bytes]]]:
+    async def _send_stream_data(
+        self, request: Request, stream_id: int, data: bytes
+    ) -> None:
         """
-        Read the response status and headers from the network.
+        Send a single chunk of data in one or more data frames.
+        """
+        while data:
+            max_flow = await self._wait_for_outgoing_flow(request, stream_id)
+            chunk_size = min(len(data), max_flow)
+            chunk, data = data[:chunk_size], data[chunk_size:]
+            self._h2_state.send_data(stream_id, chunk)
+            await self._write_outgoing_data(request)
+
+    async def _send_end_stream(self, request: Request, stream_id: int) -> None:
+        """
+        Send an empty data frame on on a given stream ID with the END_STREAM flag set.
+        """
+        self._h2_state.end_stream(stream_id)
+        await self._write_outgoing_data(request)
+
+    # Receiving the response...
+
+    async def _receive_response(
+        self, request: Request, stream_id: int
+    ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]]]:
+        """
+        Return the response status code and headers for a given stream ID.
         """
         while True:
-            event = await self.connection.wait_for_event(self.stream_id, timeout)
+            event = await self._receive_stream_event(request, stream_id)
             if isinstance(event, h2.events.ResponseReceived):
                 break
 
@@ -430,17 +303,287 @@ async def receive_response(
 
         return (status_code, headers)
 
-    async def body_iter(self, timeout: TimeoutDict) -> AsyncIterator[bytes]:
+    async def _receive_response_body(
+        self, request: Request, stream_id: int
+    ) -> typing.AsyncIterator[bytes]:
+        """
+        Iterator that returns the bytes of the response body for a given stream ID.
+        """
         while True:
-            event = await self.connection.wait_for_event(self.stream_id, timeout)
+            event = await self._receive_stream_event(request, stream_id)
             if isinstance(event, h2.events.DataReceived):
                 amount = event.flow_controlled_length
-                await self.connection.acknowledge_received_data(
-                    self.stream_id, amount, timeout
-                )
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                await self._write_outgoing_data(request)
                 yield event.data
-            elif isinstance(event, (h2.events.StreamEnded, h2.events.StreamReset)):
+            elif isinstance(event, h2.events.StreamEnded):
                 break
 
-    async def _response_closed(self) -> None:
-        await self.connection.close_stream(self.stream_id)
+    async def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> typing.Union[
+        h2.events.ResponseReceived, h2.events.DataReceived, h2.events.StreamEnded
+    ]:
+        """
+        Return the next available event for a given stream ID.
+
+        Will read more data from the network if required.
+        """
+        while not self._events.get(stream_id):
+            await self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        if isinstance(event, h2.events.StreamReset):
+            raise RemoteProtocolError(event)
+        return event
+
+    async def _receive_events(
+        self, request: Request, stream_id: typing.Optional[int] = None
+    ) -> None:
+        """
+        Read some data from the network until we see one or more events
+        for a given stream ID.
+        """
+        async with self._read_lock:
+            if self._connection_terminated is not None:
+                last_stream_id = self._connection_terminated.last_stream_id
+                if stream_id and last_stream_id and stream_id > last_stream_id:
+                    self._request_count -= 1
+                    raise ConnectionNotAvailable()
+                raise RemoteProtocolError(self._connection_terminated)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = await self._read_incoming_data(request)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        async with Trace(
+                            "receive_remote_settings", logger, request
+                        ) as trace:
+                            await self._receive_remote_settings_change(event)
+                            trace.return_value = event
+
+                    elif isinstance(
+                        event,
+                        (
+                            h2.events.ResponseReceived,
+                            h2.events.DataReceived,
+                            h2.events.StreamEnded,
+                            h2.events.StreamReset,
+                        ),
+                    ):
+                        if event.stream_id in self._events:
+                            self._events[event.stream_id].append(event)
+
+                    elif isinstance(event, h2.events.ConnectionTerminated):
+                        self._connection_terminated = event
+
+        await self._write_outgoing_data(request)
+
+    async def _receive_remote_settings_change(self, event: h2.events.Event) -> None:
+        max_concurrent_streams = event.changed_settings.get(
+            h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS
+        )
+        if max_concurrent_streams:
+            new_max_streams = min(
+                max_concurrent_streams.new_value,
+                self._h2_state.local_settings.max_concurrent_streams,
+            )
+            if new_max_streams and new_max_streams != self._max_streams:
+                while new_max_streams > self._max_streams:
+                    await self._max_streams_semaphore.release()
+                    self._max_streams += 1
+                while new_max_streams < self._max_streams:
+                    await self._max_streams_semaphore.acquire()
+                    self._max_streams -= 1
+
+    async def _response_closed(self, stream_id: int) -> None:
+        await self._max_streams_semaphore.release()
+        del self._events[stream_id]
+        async with self._state_lock:
+            if self._connection_terminated and not self._events:
+                await self.aclose()
+
+            elif self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: nocover
+                    await self.aclose()
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # Wrappers around network read/write operations...
+
+    async def _read_incoming_data(
+        self, request: Request
+    ) -> typing.List[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: nocover
+
+        try:
+            data = await self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        events: typing.List[h2.events.Event] = self._h2_state.receive_data(data)
+
+        return events
+
+    async def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        async with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: nocover
+
+            try:
+                await self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: nocover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    async def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow: int = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size: int = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow == 0:
+            await self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+            and not (
+                self._h2_state.state_machine.state
+                == h2.connection.ConnectionState.CLOSED
+            )
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        return self._expire_at is not None and now > self._expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/2, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> "AsyncHTTP2Connection":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[types.TracebackType] = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(
+        self, connection: AsyncHTTP2Connection, request: Request, stream_id: int
+    ) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            async with Trace("receive_response_body", logger, self._request, kwargs):
+                async for chunk in self._connection._receive_response_body(
+                    request=self._request, stream_id=self._stream_id
+                ):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with AsyncShieldCancellation():
+                await self.aclose()
+            raise exc
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            async with Trace("response_closed", logger, self._request, kwargs):
+                await self._connection._response_closed(stream_id=self._stream_id)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http_proxy.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http_proxy.py
index 275bf21..4aa7d87 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_async/http_proxy.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/http_proxy.py
@@ -1,35 +1,45 @@
-from http import HTTPStatus
-from ssl import SSLContext
-from typing import Tuple, cast
+import logging
+import ssl
+from base64 import b64encode
+from typing import Iterable, List, Mapping, Optional, Sequence, Tuple, Union
 
-from .._bytestreams import ByteStream
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
 from .._exceptions import ProxyError
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger, url_to_origin
-from .base import AsyncByteStream
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
 from .connection import AsyncHTTPConnection
-from .connection_pool import AsyncConnectionPool, ResponseByteStream
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
 
-logger = get_logger(__name__)
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
 
 
-def get_reason_phrase(status_code: int) -> str:
-    try:
-        return HTTPStatus(status_code).phrase
-    except ValueError:
-        return ""
+logger = logging.getLogger("httpcore.proxy")
 
 
 def merge_headers(
-    default_headers: Headers = None, override_headers: Headers = None
-) -> Headers:
+    default_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+    override_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+) -> List[Tuple[bytes, bytes]]:
     """
-    Append default_headers and override_headers, de-duplicating if a key existing in
-    both cases.
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
     """
-    default_headers = [] if default_headers is None else default_headers
-    override_headers = [] if override_headers is None else override_headers
-    has_override = set([key.lower() for key, value in override_headers])
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set(key.lower() for key, value in override_headers)
     default_headers = [
         (key, value)
         for key, value in default_headers
@@ -38,253 +48,321 @@ def merge_headers(
     return default_headers + override_headers
 
 
+def build_auth_header(username: bytes, password: bytes) -> bytes:
+    userpass = username + b":" + password
+    return b"Basic " + b64encode(userpass)
+
+
 class AsyncHTTPProxy(AsyncConnectionPool):
     """
-    A connection pool for making HTTP requests via an HTTP proxy.
-
-    Parameters
-    ----------
-    proxy_url:
-        The URL of the proxy service as a 4-tuple of (scheme, host, port, path).
-    proxy_headers:
-        A list of proxy headers to include.
-    proxy_mode:
-        A proxy mode to operate in. May be "DEFAULT", "FORWARD_ONLY", or "TUNNEL_ONLY".
-    ssl_context:
-        An SSL context to use for verifying connections.
-    max_connections:
-        The maximum number of concurrent connections to allow.
-    max_keepalive_connections:
-        The maximum number of connections to allow before closing keep-alive
-        connections.
-    http2:
-        Enable HTTP/2 support.
+    A connection pool that sends requests via an HTTP proxy.
     """
 
     def __init__(
         self,
-        proxy_url: URL,
-        proxy_headers: Headers = None,
-        proxy_mode: str = "DEFAULT",
-        ssl_context: SSLContext = None,
-        max_connections: int = None,
-        max_keepalive_connections: int = None,
-        keepalive_expiry: float = None,
+        proxy_url: Union[URL, bytes, str],
+        proxy_auth: Optional[Tuple[Union[bytes, str], Union[bytes, str]]] = None,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
         http2: bool = False,
-        backend: str = "auto",
-        # Deprecated argument style:
-        max_keepalive: int = None,
-    ):
-        assert proxy_mode in ("DEFAULT", "FORWARD_ONLY", "TUNNEL_ONLY")
-
-        self.proxy_origin = url_to_origin(proxy_url)
-        self.proxy_headers = [] if proxy_headers is None else proxy_headers
-        self.proxy_mode = proxy_mode
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
         super().__init__(
             ssl_context=ssl_context,
             max_connections=max_connections,
             max_keepalive_connections=max_keepalive_connections,
             keepalive_expiry=keepalive_expiry,
+            http1=http1,
             http2=http2,
-            backend=backend,
-            max_keepalive=max_keepalive,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+            socket_options=socket_options,
         )
 
-    async def handle_async_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        if self._keepalive_expiry is not None:
-            await self._keepalive_sweep()
-
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
         if (
-            self.proxy_mode == "DEFAULT" and url[0] == b"http"
-        ) or self.proxy_mode == "FORWARD_ONLY":
-            # By default HTTP requests should be forwarded.
-            logger.trace(
-                "forward_request proxy_origin=%r proxy_headers=%r method=%r url=%r",
-                self.proxy_origin,
-                self.proxy_headers,
-                method,
-                url,
-            )
-            return await self._forward_request(
-                method, url, headers=headers, stream=stream, extensions=extensions
-            )
-        else:
-            # By default HTTPS should be tunnelled.
-            logger.trace(
-                "tunnel_request proxy_origin=%r proxy_headers=%r method=%r url=%r",
-                self.proxy_origin,
-                self.proxy_headers,
-                method,
-                url,
-            )
-            return await self._tunnel_request(
-                method, url, headers=headers, stream=stream, extensions=extensions
+            self._proxy_url.scheme == b"http" and proxy_ssl_context is not None
+        ):  # pragma: no cover
+            raise RuntimeError(
+                "The `proxy_ssl_context` argument is not allowed for the http scheme"
             )
 
-    async def _forward_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        """
-        Forwarded proxy requests include the entire URL as the HTTP target,
-        rather than just the path.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-        origin = self.proxy_origin
-        connection = await self._get_connection_from_pool(origin)
-
-        if connection is None:
-            connection = AsyncHTTPConnection(
-                origin=origin,
-                http2=self._http2,
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            authorization = build_auth_header(username, password)
+            self._proxy_headers = [
+                (b"Proxy-Authorization", authorization)
+            ] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        if origin.scheme == b"http":
+            return AsyncForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                remote_origin=origin,
                 keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
+                network_backend=self._network_backend,
+                proxy_ssl_context=self._proxy_ssl_context,
             )
-            await self._add_to_pool(connection, timeout)
-
-        # Issue a forwarded proxy request...
-
-        # GET https://www.example.org/path HTTP/1.1
-        # [proxy headers]
-        # [headers]
-        scheme, host, port, path = url
-        if port is None:
-            target = b"%b://%b%b" % (scheme, host, path)
-        else:
-            target = b"%b://%b:%d%b" % (scheme, host, port, path)
-
-        url = self.proxy_origin + (target,)
-        headers = merge_headers(self.proxy_headers, headers)
-
-        (
-            status_code,
-            headers,
-            stream,
-            extensions,
-        ) = await connection.handle_async_request(
-            method, url, headers=headers, stream=stream, extensions=extensions
+        return AsyncTunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            proxy_ssl_context=self._proxy_ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
         )
 
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
+
+class AsyncForwardHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        keepalive_expiry: Optional[float] = None,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+    ) -> None:
+        self._connection = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
         )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._remote_origin = remote_origin
+
+    async def handle_async_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url),
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        return await self._connection.handle_async_request(proxy_request)
 
-        return status_code, headers, wrapped_stream, extensions
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
 
-    async def _tunnel_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, AsyncByteStream, dict]:
-        """
-        Tunnelled proxy requests require an initial CONNECT request to
-        establish the connection, and then send regular requests.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-        origin = url_to_origin(url)
-        connection = await self._get_connection_from_pool(origin)
+    async def aclose(self) -> None:
+        await self._connection.aclose()
 
-        if connection is None:
-            scheme, host, port = origin
+    def info(self) -> str:
+        return self._connection.info()
 
-            # First, create a connection to the proxy server
-            proxy_connection = AsyncHTTPConnection(
-                origin=self.proxy_origin,
-                http2=self._http2,
-                keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
-            )
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
 
-            # Issue a CONNECT request...
-
-            # CONNECT www.example.org:80 HTTP/1.1
-            # [proxy-headers]
-            target = b"%b:%d" % (host, port)
-            connect_url = self.proxy_origin + (target,)
-            connect_headers = [(b"Host", target), (b"Accept", b"*/*")]
-            connect_headers = merge_headers(connect_headers, self.proxy_headers)
-
-            try:
-                (
-                    proxy_status_code,
-                    _,
-                    proxy_stream,
-                    _,
-                ) = await proxy_connection.handle_async_request(
-                    b"CONNECT",
-                    connect_url,
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+
+class AsyncTunnelHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: Optional[AsyncNetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        self._connection: AsyncConnectionInterface = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = AsyncLock()
+        self._connected = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers(
+                    [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+                )
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
                     headers=connect_headers,
-                    stream=ByteStream(b""),
-                    extensions=extensions,
+                    extensions=request.extensions,
                 )
-
-                proxy_reason = get_reason_phrase(proxy_status_code)
-                logger.trace(
-                    "tunnel_response proxy_status_code=%r proxy_reason=%r ",
-                    proxy_status_code,
-                    proxy_reason,
+                connect_response = await self._connection.handle_async_request(
+                    connect_request
                 )
-                # Read the response data without closing the socket
-                async for _ in proxy_stream:
-                    pass
 
-                # See if the tunnel was successfully established.
-                if proxy_status_code < 200 or proxy_status_code > 299:
-                    msg = "%d %s" % (proxy_status_code, proxy_reason)
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = "%d %s" % (connect_response.status, reason_str)
+                    await self._connection.aclose()
                     raise ProxyError(msg)
 
-                # Upgrade to TLS if required
-                # We assume the target speaks TLS on the specified port
-                if scheme == b"https":
-                    await proxy_connection.start_tls(host, self._ssl_context, timeout)
-            except Exception as exc:
-                await proxy_connection.aclose()
-                raise ProxyError(exc)
-
-            # The CONNECT request is successful, so we have now SWITCHED PROTOCOLS.
-            # This means the proxy connection is now unusable, and we must create
-            # a new one for regular requests, making sure to use the same socket to
-            # retain the tunnel.
-            connection = AsyncHTTPConnection(
-                origin=origin,
-                http2=self._http2,
-                keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
-                socket=proxy_connection.socket,
-            )
-            await self._add_to_pool(connection, timeout)
-
-        # Once the connection has been established we can send requests on
-        # it as normal.
-        (
-            status_code,
-            headers,
-            stream,
-            extensions,
-        ) = await connection.handle_async_request(
-            method,
-            url,
-            headers=headers,
-            stream=stream,
-            extensions=extensions,
-        )
+                stream = connect_response.extensions["network_stream"]
 
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
-        )
+                # Upgrade the stream to SSL
+                ssl_context = (
+                    default_ssl_context()
+                    if self._ssl_context is None
+                    else self._ssl_context
+                )
+                alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": self._remote_origin.host.decode("ascii"),
+                    "timeout": timeout,
+                }
+                async with Trace("start_tls", logger, request, kwargs) as trace:
+                    stream = await stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = (
+                    ssl_object is not None
+                    and ssl_object.selected_alpn_protocol() == "h2"
+                )
+
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import AsyncHTTP2Connection
+
+                    self._connection = AsyncHTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = AsyncHTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        await self._connection.aclose()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
 
-        return status_code, headers, wrapped_stream, extensions
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/interfaces.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/interfaces.py
new file mode 100644
index 0000000..c998dd2
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/interfaces.py
@@ -0,0 +1,135 @@
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Optional, Union
+
+from .._models import (
+    URL,
+    Extensions,
+    HeaderTypes,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class AsyncRequestInterface:
+    async def request(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, AsyncIterator[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            await response.aread()
+        finally:
+            await response.aclose()
+        return response
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, AsyncIterator[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> AsyncIterator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    async def handle_async_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: nocover
+
+
+class AsyncConnectionInterface(AsyncRequestInterface):
+    async def aclose(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: nocover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_async/socks_proxy.py b/addon/globalPlugins/spellcheck/libs/httpcore/_async/socks_proxy.py
new file mode 100644
index 0000000..f839603
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_async/socks_proxy.py
@@ -0,0 +1,342 @@
+import logging
+import ssl
+import typing
+
+from socksio import socks5
+
+from .._backends.auto import AutoBackend
+from .._backends.base import AsyncNetworkBackend, AsyncNetworkStream
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+logger = logging.getLogger("httpcore.socks")
+
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+async def _init_socks5_connection(
+    stream: AsyncNetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+) -> None:
+    conn = socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes)
+
+    # Auth method response
+    incoming_bytes = await stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(
+            f"Requested {requested} from proxy server, but got {responded}."
+        )
+
+    if response.method == socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        await stream.write(outgoing_bytes)
+
+        # Username/password response
+        incoming_bytes = await stream.read(max_bytes=4096)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(
+        socks5.SOCKS5CommandRequest.from_address(
+            socks5.SOCKS5Command.CONNECT, (host, port)
+        )
+    )
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes)
+
+    # Connect response
+    incoming_bytes = await stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5Reply)
+    if response.reply_code != socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class AsyncSOCKSProxy(AsyncConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: typing.Union[URL, bytes, str],
+        proxy_auth: typing.Optional[
+            typing.Tuple[typing.Union[bytes, str], typing.Union[bytes, str]]
+        ] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        max_connections: typing.Optional[int] = 10,
+        max_keepalive_connections: typing.Optional[int] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        network_backend: typing.Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        return AsyncSocks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class AsyncSocks5Connection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[AsyncNetworkBackend] = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: AsyncNetworkBackend = (
+            AutoBackend() if network_backend is None else network_backend
+        )
+        self._connect_lock = AsyncLock()
+        self._connection: typing.Optional[AsyncConnectionInterface] = None
+        self._connect_failed = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    async with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                    }
+                    async with Trace(
+                        "setup_socks5_connection", logger, request, kwargs
+                    ) as trace:
+                        await _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme == b"https":
+                        ssl_context = (
+                            default_ssl_context()
+                            if self._ssl_context is None
+                            else self._ssl_context
+                        )
+                        alpn_protocols = (
+                            ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": sni_hostname
+                            or self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        async with Trace("start_tls", logger, request, kwargs) as trace:
+                            stream = await stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (
+                        self._http2 and not self._http1
+                    ):  # pragma: nocover
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: nocover
+                raise ConnectionNotAvailable()
+
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        if self._connection is not None:
+            await self._connection.aclose()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._remote_origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: nocover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/anyio.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/anyio.py
index b1332a2..1ed5228 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/anyio.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/anyio.py
@@ -1,10 +1,7 @@
-from ssl import SSLContext
-from typing import Optional
+import ssl
+import typing
 
-import anyio.abc
-from anyio import BrokenResourceError, EndOfStream
-from anyio.abc import ByteStream, SocketAttribute
-from anyio.streams.tls import TLSAttribute, TLSStream
+import anyio
 
 from .._exceptions import (
     ConnectError,
@@ -15,187 +12,134 @@
     WriteTimeout,
     map_exceptions,
 )
-from .._types import TimeoutDict
 from .._utils import is_socket_readable
-from .base import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
 
 
-class SocketStream(AsyncSocketStream):
-    def __init__(self, stream: ByteStream) -> None:
-        self.stream = stream
-        self.read_lock = anyio.Lock()
-        self.write_lock = anyio.Lock()
+class AnyIOStream(AsyncNetworkStream):
+    def __init__(self, stream: anyio.abc.ByteStream) -> None:
+        self._stream = stream
 
-    def get_http_version(self) -> str:
-        alpn_protocol = self.stream.extra(TLSAttribute.alpn_protocol, None)
-        return "HTTP/2" if alpn_protocol == "h2" else "HTTP/1.1"
-
-    async def start_tls(
-        self,
-        hostname: bytes,
-        ssl_context: SSLContext,
-        timeout: TimeoutDict,
-    ) -> "SocketStream":
-        connect_timeout = timeout.get("connect")
-        try:
-            with anyio.fail_after(connect_timeout):
-                ssl_stream = await TLSStream.wrap(
-                    self.stream,
-                    ssl_context=ssl_context,
-                    hostname=hostname.decode("ascii"),
-                    standard_compatible=False,
-                )
-        except TimeoutError:
-            raise ConnectTimeout from None
-        except BrokenResourceError as exc:
-            raise ConnectError from exc
-
-        return SocketStream(ssl_stream)
-
-    async def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        read_timeout = timeout.get("read")
-        async with self.read_lock:
-            try:
-                with anyio.fail_after(read_timeout):
-                    return await self.stream.receive(n)
-            except TimeoutError:
-                await self.stream.aclose()
-                raise ReadTimeout from None
-            except BrokenResourceError as exc:
-                raise ReadError from exc
-            except EndOfStream:
-                return b""
-
-    async def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        if not data:
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        exc_map = {
+            TimeoutError: ReadTimeout,
+            anyio.BrokenResourceError: ReadError,
+            anyio.ClosedResourceError: ReadError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                try:
+                    return await self._stream.receive(max_bytes=max_bytes)
+                except anyio.EndOfStream:  # pragma: nocover
+                    return b""
+
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        if not buffer:
             return
 
-        write_timeout = timeout.get("write")
-        async with self.write_lock:
-            try:
-                with anyio.fail_after(write_timeout):
-                    return await self.stream.send(data)
-            except TimeoutError:
-                await self.stream.aclose()
-                raise WriteTimeout from None
-            except BrokenResourceError as exc:
-                raise WriteError from exc
+        exc_map = {
+            TimeoutError: WriteTimeout,
+            anyio.BrokenResourceError: WriteError,
+            anyio.ClosedResourceError: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                await self._stream.send(item=buffer)
 
     async def aclose(self) -> None:
-        async with self.write_lock:
-            try:
-                await self.stream.aclose()
-            except BrokenResourceError:
-                pass
-
-    def is_readable(self) -> bool:
-        sock = self.stream.extra(SocketAttribute.raw_socket)
-        return is_socket_readable(sock)
-
-
-class Lock(AsyncLock):
-    def __init__(self) -> None:
-        self._lock = anyio.Lock()
-
-    async def release(self) -> None:
-        self._lock.release()
-
-    async def acquire(self) -> None:
-        await self._lock.acquire()
-
-
-class Semaphore(AsyncSemaphore):
-    def __init__(self, max_value: int, exc_class: type):
-        self.max_value = max_value
-        self.exc_class = exc_class
-
-    @property
-    def semaphore(self) -> anyio.abc.Semaphore:
-        if not hasattr(self, "_semaphore"):
-            self._semaphore = anyio.Semaphore(self.max_value)
-        return self._semaphore
-
-    async def acquire(self, timeout: float = None) -> None:
-        with anyio.move_on_after(timeout):
-            await self.semaphore.acquire()
-            return
+        await self._stream.aclose()
 
-        raise self.exc_class()
-
-    async def release(self) -> None:
-        self.semaphore.release()
-
-
-class AnyIOBackend(AsyncBackend):
-    async def open_tcp_stream(
+    async def start_tls(
         self,
-        hostname: bytes,
-        port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> AsyncSocketStream:
-        connect_timeout = timeout.get("connect")
-        unicode_host = hostname.decode("utf-8")
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncNetworkStream:
         exc_map = {
             TimeoutError: ConnectTimeout,
-            OSError: ConnectError,
-            BrokenResourceError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
         }
-
         with map_exceptions(exc_map):
-            with anyio.fail_after(connect_timeout):
-                stream: anyio.abc.ByteStream
-                stream = await anyio.connect_tcp(
-                    unicode_host, port, local_host=local_address
-                )
-                if ssl_context:
-                    stream = await TLSStream.wrap(
-                        stream,
-                        hostname=unicode_host,
+            try:
+                with anyio.fail_after(timeout):
+                    ssl_stream = await anyio.streams.tls.TLSStream.wrap(
+                        self._stream,
                         ssl_context=ssl_context,
+                        hostname=server_hostname,
                         standard_compatible=False,
+                        server_side=False,
                     )
+            except Exception as exc:  # pragma: nocover
+                await self.aclose()
+                raise exc
+        return AnyIOStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object":
+            return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None)
+        if info == "client_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.local_address, None)
+        if info == "server_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None)
+        if info == "socket":
+            return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+        if info == "is_readable":
+            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+            return is_socket_readable(sock)
+        return None
+
+
+class AnyIOBackend(AsyncNetworkBackend):
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
+        exc_map = {
+            TimeoutError: ConnectTimeout,
+            OSError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                stream: anyio.abc.ByteStream = await anyio.connect_tcp(
+                    remote_host=host,
+                    remote_port=port,
+                    local_host=local_address,
+                )
+                # By default TCP sockets opened in `asyncio` include TCP_NODELAY.
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return AnyIOStream(stream)
 
-        return SocketStream(stream=stream)
-
-    async def open_uds_stream(
+    async def connect_unix_socket(
         self,
         path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        connect_timeout = timeout.get("connect")
-        unicode_host = hostname.decode("utf-8")
+        timeout: typing.Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        if socket_options is None:
+            socket_options = []
         exc_map = {
             TimeoutError: ConnectTimeout,
             OSError: ConnectError,
-            BrokenResourceError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
         }
-
         with map_exceptions(exc_map):
-            with anyio.fail_after(connect_timeout):
+            with anyio.fail_after(timeout):
                 stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
-                if ssl_context:
-                    stream = await TLSStream.wrap(
-                        stream,
-                        hostname=unicode_host,
-                        ssl_context=ssl_context,
-                        standard_compatible=False,
-                    )
-
-        return SocketStream(stream=stream)
-
-    def create_lock(self) -> AsyncLock:
-        return Lock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        return Semaphore(max_value, exc_class=exc_class)
-
-    async def time(self) -> float:
-        return float(anyio.current_time())
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return AnyIOStream(stream)
 
     async def sleep(self, seconds: float) -> None:
-        await anyio.sleep(seconds)
+        await anyio.sleep(seconds)  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/asyncio.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/asyncio.py
deleted file mode 100644
index 5142072..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/asyncio.py
+++ /dev/null
@@ -1,303 +0,0 @@
-import asyncio
-import socket
-from ssl import SSLContext
-from typing import Optional
-
-from .._exceptions import (
-    ConnectError,
-    ConnectTimeout,
-    ReadError,
-    ReadTimeout,
-    WriteError,
-    WriteTimeout,
-    map_exceptions,
-)
-from .._types import TimeoutDict
-from .._utils import is_socket_readable
-from .base import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
-
-SSL_MONKEY_PATCH_APPLIED = False
-
-
-def ssl_monkey_patch() -> None:
-    """
-    Monkey-patch for https://bugs.python.org/issue36709
-
-    This prevents console errors when outstanding HTTPS connections
-    still exist at the point of exiting.
-
-    Clients which have been opened using a `with` block, or which have
-    had `close()` closed, will not exhibit this issue in the first place.
-    """
-    MonkeyPatch = asyncio.selector_events._SelectorSocketTransport  # type: ignore
-
-    _write = MonkeyPatch.write
-
-    def _fixed_write(self, data: bytes) -> None:  # type: ignore
-        if self._loop and not self._loop.is_closed():
-            _write(self, data)
-
-    MonkeyPatch.write = _fixed_write
-
-
-async def backport_start_tls(
-    transport: asyncio.BaseTransport,
-    protocol: asyncio.BaseProtocol,
-    ssl_context: SSLContext,
-    *,
-    server_side: bool = False,
-    server_hostname: str = None,
-    ssl_handshake_timeout: float = None,
-) -> asyncio.Transport:  # pragma: nocover (Since it's not used on all Python versions.)
-    """
-    Python 3.6 asyncio doesn't have a start_tls() method on the loop
-    so we use this function in place of the loop's start_tls() method.
-    Adapted from this comment:
-    https://github.com/urllib3/urllib3/issues/1323#issuecomment-362494839
-    """
-    import asyncio.sslproto
-
-    loop = asyncio.get_event_loop()
-    waiter = loop.create_future()
-    ssl_protocol = asyncio.sslproto.SSLProtocol(
-        loop,
-        protocol,
-        ssl_context,
-        waiter,
-        server_side=False,
-        server_hostname=server_hostname,
-        call_connection_made=False,
-    )
-
-    transport.set_protocol(ssl_protocol)
-    loop.call_soon(ssl_protocol.connection_made, transport)
-    loop.call_soon(transport.resume_reading)  # type: ignore
-
-    await waiter
-    return ssl_protocol._app_transport
-
-
-class SocketStream(AsyncSocketStream):
-    def __init__(
-        self, stream_reader: asyncio.StreamReader, stream_writer: asyncio.StreamWriter
-    ):
-        self.stream_reader = stream_reader
-        self.stream_writer = stream_writer
-        self.read_lock = asyncio.Lock()
-        self.write_lock = asyncio.Lock()
-
-    def get_http_version(self) -> str:
-        ssl_object = self.stream_writer.get_extra_info("ssl_object")
-
-        if ssl_object is None:
-            return "HTTP/1.1"
-
-        ident = ssl_object.selected_alpn_protocol()
-        return "HTTP/2" if ident == "h2" else "HTTP/1.1"
-
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict
-    ) -> "SocketStream":
-        loop = asyncio.get_event_loop()
-
-        stream_reader = asyncio.StreamReader()
-        protocol = asyncio.StreamReaderProtocol(stream_reader)
-        transport = self.stream_writer.transport
-
-        loop_start_tls = getattr(loop, "start_tls", backport_start_tls)
-
-        exc_map = {asyncio.TimeoutError: ConnectTimeout, OSError: ConnectError}
-
-        with map_exceptions(exc_map):
-            transport = await asyncio.wait_for(
-                loop_start_tls(
-                    transport,
-                    protocol,
-                    ssl_context,
-                    server_hostname=hostname.decode("ascii"),
-                ),
-                timeout=timeout.get("connect"),
-            )
-
-        # Initialize the protocol, so it is made aware of being tied to
-        # a TLS connection.
-        # See: https://github.com/encode/httpx/issues/859
-        protocol.connection_made(transport)
-
-        stream_writer = asyncio.StreamWriter(
-            transport=transport, protocol=protocol, reader=stream_reader, loop=loop
-        )
-
-        ssl_stream = SocketStream(stream_reader, stream_writer)
-        # When we return a new SocketStream with new StreamReader/StreamWriter instances
-        # we need to keep references to the old StreamReader/StreamWriter so that they
-        # are not garbage collected and closed while we're still using them.
-        ssl_stream._inner = self  # type: ignore
-        return ssl_stream
-
-    async def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        exc_map = {asyncio.TimeoutError: ReadTimeout, OSError: ReadError}
-        async with self.read_lock:
-            with map_exceptions(exc_map):
-                try:
-                    return await asyncio.wait_for(
-                        self.stream_reader.read(n), timeout.get("read")
-                    )
-                except AttributeError as exc:  # pragma: nocover
-                    if "resume_reading" in str(exc):
-                        # Python's asyncio has a bug that can occur when a
-                        # connection has been closed, while it is paused.
-                        # See: https://github.com/encode/httpx/issues/1213
-                        #
-                        # Returning an empty byte-string to indicate connection
-                        # close will eventually raise an httpcore.RemoteProtocolError
-                        # to the user when this goes through our HTTP parsing layer.
-                        return b""
-                    raise
-
-    async def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        if not data:
-            return
-
-        exc_map = {asyncio.TimeoutError: WriteTimeout, OSError: WriteError}
-        async with self.write_lock:
-            with map_exceptions(exc_map):
-                self.stream_writer.write(data)
-                return await asyncio.wait_for(
-                    self.stream_writer.drain(), timeout.get("write")
-                )
-
-    async def aclose(self) -> None:
-        # SSL connections should issue the close and then abort, rather than
-        # waiting for the remote end of the connection to signal the EOF.
-        #
-        # See:
-        #
-        # * https://bugs.python.org/issue39758
-        # * https://github.com/python-trio/trio/blob/
-        #             31e2ae866ad549f1927d45ce073d4f0ea9f12419/trio/_ssl.py#L779-L829
-        #
-        # And related issues caused if we simply omit the 'wait_closed' call,
-        # without first using `.abort()`
-        #
-        # * https://github.com/encode/httpx/issues/825
-        # * https://github.com/encode/httpx/issues/914
-        is_ssl = self.stream_writer.get_extra_info("ssl_object") is not None
-
-        async with self.write_lock:
-            try:
-                self.stream_writer.close()
-                if is_ssl:
-                    # Give the connection a chance to write any data in the buffer,
-                    # and then forcibly tear down the SSL connection.
-                    await asyncio.sleep(0)
-                    self.stream_writer.transport.abort()  # type: ignore
-                if hasattr(self.stream_writer, "wait_closed"):
-                    # Python 3.7+ only.
-                    await self.stream_writer.wait_closed()  # type: ignore
-            except OSError:
-                pass
-
-    def is_readable(self) -> bool:
-        transport = self.stream_reader._transport  # type: ignore
-        sock: Optional[socket.socket] = transport.get_extra_info("socket")
-        return is_socket_readable(sock)
-
-
-class Lock(AsyncLock):
-    def __init__(self) -> None:
-        self._lock = asyncio.Lock()
-
-    async def release(self) -> None:
-        self._lock.release()
-
-    async def acquire(self) -> None:
-        await self._lock.acquire()
-
-
-class Semaphore(AsyncSemaphore):
-    def __init__(self, max_value: int, exc_class: type) -> None:
-        self.max_value = max_value
-        self.exc_class = exc_class
-
-    @property
-    def semaphore(self) -> asyncio.BoundedSemaphore:
-        if not hasattr(self, "_semaphore"):
-            self._semaphore = asyncio.BoundedSemaphore(value=self.max_value)
-        return self._semaphore
-
-    async def acquire(self, timeout: float = None) -> None:
-        try:
-            await asyncio.wait_for(self.semaphore.acquire(), timeout)
-        except asyncio.TimeoutError:
-            raise self.exc_class()
-
-    async def release(self) -> None:
-        self.semaphore.release()
-
-
-class AsyncioBackend(AsyncBackend):
-    def __init__(self) -> None:
-        global SSL_MONKEY_PATCH_APPLIED
-
-        if not SSL_MONKEY_PATCH_APPLIED:
-            ssl_monkey_patch()
-        SSL_MONKEY_PATCH_APPLIED = True
-
-    async def open_tcp_stream(
-        self,
-        hostname: bytes,
-        port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> SocketStream:
-        host = hostname.decode("ascii")
-        connect_timeout = timeout.get("connect")
-        local_addr = None if local_address is None else (local_address, 0)
-
-        exc_map = {asyncio.TimeoutError: ConnectTimeout, OSError: ConnectError}
-        with map_exceptions(exc_map):
-            stream_reader, stream_writer = await asyncio.wait_for(
-                asyncio.open_connection(
-                    host, port, ssl=ssl_context, local_addr=local_addr
-                ),
-                connect_timeout,
-            )
-            return SocketStream(
-                stream_reader=stream_reader, stream_writer=stream_writer
-            )
-
-    async def open_uds_stream(
-        self,
-        path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        host = hostname.decode("ascii")
-        connect_timeout = timeout.get("connect")
-        kwargs: dict = {"server_hostname": host} if ssl_context is not None else {}
-        exc_map = {asyncio.TimeoutError: ConnectTimeout, OSError: ConnectError}
-        with map_exceptions(exc_map):
-            stream_reader, stream_writer = await asyncio.wait_for(
-                asyncio.open_unix_connection(path, ssl=ssl_context, **kwargs),
-                connect_timeout,
-            )
-            return SocketStream(
-                stream_reader=stream_reader, stream_writer=stream_writer
-            )
-
-    def create_lock(self) -> AsyncLock:
-        return Lock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        return Semaphore(max_value, exc_class=exc_class)
-
-    async def time(self) -> float:
-        loop = asyncio.get_event_loop()
-        return loop.time()
-
-    async def sleep(self, seconds: float) -> None:
-        await asyncio.sleep(seconds)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/auto.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/auto.py
index 5579ab4..3ac05f4 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/auto.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/auto.py
@@ -1,67 +1,51 @@
-from ssl import SSLContext
+import typing
 from typing import Optional
 
-import sniffio
+from .._synchronization import current_async_library
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
 
-from .._types import TimeoutDict
-from .base import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
 
-# The following line is imported from the _sync modules
-from .sync import SyncBackend, SyncLock, SyncSemaphore, SyncSocketStream  # noqa
-
-
-class AutoBackend(AsyncBackend):
-    @property
-    def backend(self) -> AsyncBackend:
-        if not hasattr(self, "_backend_implementation"):
-            backend = sniffio.current_async_library()
-
-            if backend == "asyncio":
-                from .anyio import AnyIOBackend
-
-                self._backend_implementation: AsyncBackend = AnyIOBackend()
-            elif backend == "trio":
+class AutoBackend(AsyncNetworkBackend):
+    async def _init_backend(self) -> None:
+        if not (hasattr(self, "_backend")):
+            backend = current_async_library()
+            if backend == "trio":
                 from .trio import TrioBackend
 
-                self._backend_implementation = TrioBackend()
-            elif backend == "curio":
-                from .curio import CurioBackend
+                self._backend: AsyncNetworkBackend = TrioBackend()
+            else:
+                from .anyio import AnyIOBackend
 
-                self._backend_implementation = CurioBackend()
-            else:  # pragma: nocover
-                raise RuntimeError(f"Unsupported concurrency backend {backend!r}")
-        return self._backend_implementation
+                self._backend = AnyIOBackend()
 
-    async def open_tcp_stream(
+    async def connect_tcp(
         self,
-        hostname: bytes,
+        host: str,
         port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> AsyncSocketStream:
-        return await self.backend.open_tcp_stream(
-            hostname, port, ssl_context, timeout, local_address=local_address
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        await self._init_backend()
+        return await self._backend.connect_tcp(
+            host,
+            port,
+            timeout=timeout,
+            local_address=local_address,
+            socket_options=socket_options,
         )
 
-    async def open_uds_stream(
+    async def connect_unix_socket(
         self,
         path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        return await self.backend.open_uds_stream(path, hostname, ssl_context, timeout)
-
-    def create_lock(self) -> AsyncLock:
-        return self.backend.create_lock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        return self.backend.create_semaphore(max_value, exc_class=exc_class)
-
-    async def time(self) -> float:
-        return await self.backend.time()
+        timeout: Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        await self._init_backend()
+        return await self._backend.connect_unix_socket(
+            path, timeout=timeout, socket_options=socket_options
+        )
 
-    async def sleep(self, seconds: float) -> None:
-        await self.backend.sleep(seconds)
+    async def sleep(self, seconds: float) -> None:  # pragma: nocover
+        await self._init_backend()
+        return await self._backend.sleep(seconds)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/base.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/base.py
index 1ca6e31..6cadedb 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/base.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/base.py
@@ -1,137 +1,103 @@
-from ssl import SSLContext
-from types import TracebackType
-from typing import TYPE_CHECKING, Optional, Type
+import ssl
+import time
+import typing
 
-from .._types import TimeoutDict
+SOCKET_OPTION = typing.Union[
+    typing.Tuple[int, int, int],
+    typing.Tuple[int, int, typing.Union[bytes, bytearray]],
+    typing.Tuple[int, int, None, int],
+]
 
-if TYPE_CHECKING:  # pragma: no cover
-    from .sync import SyncBackend
 
+class NetworkStream:
+    def read(self, max_bytes: int, timeout: typing.Optional[float] = None) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
 
-def lookup_async_backend(name: str) -> "AsyncBackend":
-    if name == "auto":
-        from .auto import AutoBackend
+    def write(self, buffer: bytes, timeout: typing.Optional[float] = None) -> None:
+        raise NotImplementedError()  # pragma: nocover
 
-        return AutoBackend()
-    elif name == "asyncio":
-        from .asyncio import AsyncioBackend
-
-        return AsyncioBackend()
-    elif name == "trio":
-        from .trio import TrioBackend
-
-        return TrioBackend()
-    elif name == "curio":
-        from .curio import CurioBackend
-
-        return CurioBackend()
-    elif name == "anyio":
-        from .anyio import AnyIOBackend
-
-        return AnyIOBackend()
-
-    raise ValueError("Invalid backend name {name!r}")
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
 
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "NetworkStream":
+        raise NotImplementedError()  # pragma: nocover
 
-def lookup_sync_backend(name: str) -> "SyncBackend":
-    from .sync import SyncBackend
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: nocover
 
-    return SyncBackend()
 
+class NetworkBackend:
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: nocover
 
-class AsyncSocketStream:
-    """
-    A socket stream with read/write operations. Abstracts away any asyncio-specific
-    interfaces into a more generic base class, that we can use with alternate
-    backends, or for stand-alone test cases.
-    """
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: typing.Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: nocover
 
-    def get_http_version(self) -> str:
-        raise NotImplementedError()  # pragma: no cover
+    def sleep(self, seconds: float) -> None:
+        time.sleep(seconds)  # pragma: nocover
 
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict
-    ) -> "AsyncSocketStream":
-        raise NotImplementedError()  # pragma: no cover
 
-    async def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        raise NotImplementedError()  # pragma: no cover
+class AsyncNetworkStream:
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        raise NotImplementedError()  # pragma: nocover
 
-    async def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        raise NotImplementedError()  # pragma: no cover
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        raise NotImplementedError()  # pragma: nocover
 
     async def aclose(self) -> None:
-        raise NotImplementedError()  # pragma: no cover
-
-    def is_readable(self) -> bool:
-        raise NotImplementedError()  # pragma: no cover
-
+        raise NotImplementedError()  # pragma: nocover
 
-class AsyncLock:
-    """
-    An abstract interface for Lock classes.
-    """
-
-    async def __aenter__(self) -> None:
-        await self.acquire()
-
-    async def __aexit__(
+    async def start_tls(
         self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        await self.release()
-
-    async def release(self) -> None:
-        raise NotImplementedError()  # pragma: no cover
-
-    async def acquire(self) -> None:
-        raise NotImplementedError()  # pragma: no cover
-
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "AsyncNetworkStream":
+        raise NotImplementedError()  # pragma: nocover
 
-class AsyncSemaphore:
-    """
-    An abstract interface for Semaphore classes.
-    Abstracts away any asyncio-specific interfaces.
-    """
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: nocover
 
-    async def acquire(self, timeout: float = None) -> None:
-        raise NotImplementedError()  # pragma: no cover
 
-    async def release(self) -> None:
-        raise NotImplementedError()  # pragma: no cover
-
-
-class AsyncBackend:
-    async def open_tcp_stream(
+class AsyncNetworkBackend:
+    async def connect_tcp(
         self,
-        hostname: bytes,
+        host: str,
         port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> AsyncSocketStream:
-        raise NotImplementedError()  # pragma: no cover
-
-    async def open_uds_stream(
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: nocover
+
+    async def connect_unix_socket(
         self,
         path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        raise NotImplementedError()  # pragma: no cover
-
-    def create_lock(self) -> AsyncLock:
-        raise NotImplementedError()  # pragma: no cover
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        raise NotImplementedError()  # pragma: no cover
-
-    async def time(self) -> float:
-        raise NotImplementedError()  # pragma: no cover
+        timeout: typing.Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: nocover
 
     async def sleep(self, seconds: float) -> None:
-        raise NotImplementedError()  # pragma: no cover
+        raise NotImplementedError()  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/curio.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/curio.py
deleted file mode 100644
index 99a7b2c..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/curio.py
+++ /dev/null
@@ -1,206 +0,0 @@
-from ssl import SSLContext, SSLSocket
-from typing import Optional
-
-import curio
-import curio.io
-
-from .._exceptions import (
-    ConnectError,
-    ConnectTimeout,
-    ReadError,
-    ReadTimeout,
-    WriteError,
-    WriteTimeout,
-    map_exceptions,
-)
-from .._types import TimeoutDict
-from .._utils import get_logger, is_socket_readable
-from .base import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
-
-logger = get_logger(__name__)
-
-ONE_DAY_IN_SECONDS = float(60 * 60 * 24)
-
-
-def convert_timeout(value: Optional[float]) -> float:
-    return value if value is not None else ONE_DAY_IN_SECONDS
-
-
-class Lock(AsyncLock):
-    def __init__(self) -> None:
-        self._lock = curio.Lock()
-
-    async def acquire(self) -> None:
-        await self._lock.acquire()
-
-    async def release(self) -> None:
-        await self._lock.release()
-
-
-class Semaphore(AsyncSemaphore):
-    def __init__(self, max_value: int, exc_class: type) -> None:
-        self.max_value = max_value
-        self.exc_class = exc_class
-
-    @property
-    def semaphore(self) -> curio.Semaphore:
-        if not hasattr(self, "_semaphore"):
-            self._semaphore = curio.Semaphore(value=self.max_value)
-        return self._semaphore
-
-    async def acquire(self, timeout: float = None) -> None:
-        timeout = convert_timeout(timeout)
-
-        try:
-            return await curio.timeout_after(timeout, self.semaphore.acquire())
-        except curio.TaskTimeout:
-            raise self.exc_class()
-
-    async def release(self) -> None:
-        await self.semaphore.release()
-
-
-class SocketStream(AsyncSocketStream):
-    def __init__(self, socket: curio.io.Socket) -> None:
-        self.read_lock = curio.Lock()
-        self.write_lock = curio.Lock()
-        self.socket = socket
-        self.stream = socket.as_stream()
-
-    def get_http_version(self) -> str:
-        if hasattr(self.socket, "_socket"):
-            raw_socket = self.socket._socket
-
-            if isinstance(raw_socket, SSLSocket):
-                ident = raw_socket.selected_alpn_protocol()
-                return "HTTP/2" if ident == "h2" else "HTTP/1.1"
-
-        return "HTTP/1.1"
-
-    async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict
-    ) -> "AsyncSocketStream":
-        connect_timeout = convert_timeout(timeout.get("connect"))
-        exc_map = {
-            curio.TaskTimeout: ConnectTimeout,
-            curio.CurioError: ConnectError,
-            OSError: ConnectError,
-        }
-
-        with map_exceptions(exc_map):
-            wrapped_sock = curio.io.Socket(
-                ssl_context.wrap_socket(
-                    self.socket._socket,
-                    do_handshake_on_connect=False,
-                    server_hostname=hostname.decode("ascii"),
-                )
-            )
-
-            await curio.timeout_after(
-                connect_timeout,
-                wrapped_sock.do_handshake(),
-            )
-
-            return SocketStream(wrapped_sock)
-
-    async def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        read_timeout = convert_timeout(timeout.get("read"))
-        exc_map = {
-            curio.TaskTimeout: ReadTimeout,
-            curio.CurioError: ReadError,
-            OSError: ReadError,
-        }
-
-        with map_exceptions(exc_map):
-            async with self.read_lock:
-                return await curio.timeout_after(read_timeout, self.stream.read(n))
-
-    async def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        write_timeout = convert_timeout(timeout.get("write"))
-        exc_map = {
-            curio.TaskTimeout: WriteTimeout,
-            curio.CurioError: WriteError,
-            OSError: WriteError,
-        }
-
-        with map_exceptions(exc_map):
-            async with self.write_lock:
-                await curio.timeout_after(write_timeout, self.stream.write(data))
-
-    async def aclose(self) -> None:
-        await self.stream.close()
-        await self.socket.close()
-
-    def is_readable(self) -> bool:
-        return is_socket_readable(self.socket)
-
-
-class CurioBackend(AsyncBackend):
-    async def open_tcp_stream(
-        self,
-        hostname: bytes,
-        port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> AsyncSocketStream:
-        connect_timeout = convert_timeout(timeout.get("connect"))
-        exc_map = {
-            curio.TaskTimeout: ConnectTimeout,
-            curio.CurioError: ConnectError,
-            OSError: ConnectError,
-        }
-        host = hostname.decode("ascii")
-
-        kwargs: dict = {}
-        if ssl_context is not None:
-            kwargs["ssl"] = ssl_context
-            kwargs["server_hostname"] = host
-        if local_address is not None:
-            kwargs["source_addr"] = (local_address, 0)
-
-        with map_exceptions(exc_map):
-            sock: curio.io.Socket = await curio.timeout_after(
-                connect_timeout,
-                curio.open_connection(hostname, port, **kwargs),
-            )
-
-            return SocketStream(sock)
-
-    async def open_uds_stream(
-        self,
-        path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        connect_timeout = convert_timeout(timeout.get("connect"))
-        exc_map = {
-            curio.TaskTimeout: ConnectTimeout,
-            curio.CurioError: ConnectError,
-            OSError: ConnectError,
-        }
-        host = hostname.decode("ascii")
-        kwargs = (
-            {} if ssl_context is None else {"ssl": ssl_context, "server_hostname": host}
-        )
-
-        with map_exceptions(exc_map):
-            sock: curio.io.Socket = await curio.timeout_after(
-                connect_timeout, curio.open_unix_connection(path, **kwargs)
-            )
-
-            return SocketStream(sock)
-
-    def create_lock(self) -> AsyncLock:
-        return Lock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        return Semaphore(max_value, exc_class)
-
-    async def time(self) -> float:
-        return await curio.clock()
-
-    async def sleep(self, seconds: float) -> None:
-        await curio.sleep(seconds)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/mock.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/mock.py
new file mode 100644
index 0000000..f7aefeb
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/mock.py
@@ -0,0 +1,142 @@
+import ssl
+import typing
+from typing import Optional
+
+from .._exceptions import ReadError
+from .base import (
+    SOCKET_OPTION,
+    AsyncNetworkBackend,
+    AsyncNetworkStream,
+    NetworkBackend,
+    NetworkStream,
+)
+
+
+class MockSSLObject:
+    def __init__(self, http2: bool):
+        self._http2 = http2
+
+    def selected_alpn_protocol(self) -> str:
+        return "h2" if self._http2 else "http/1.1"
+
+
+class MockStream(NetworkStream):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+        self._closed = False
+
+    def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if self._closed:
+            raise ReadError("Connection closed")
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        pass
+
+    def close(self) -> None:
+        self._closed = True
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> NetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+    def __repr__(self) -> str:
+        return "<httpcore.MockStream>"
+
+
+class MockBackend(NetworkBackend):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def sleep(self, seconds: float) -> None:
+        pass
+
+
+class AsyncMockStream(AsyncNetworkStream):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+        self._closed = False
+
+    async def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if self._closed:
+            raise ReadError("Connection closed")
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    async def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        pass
+
+    async def aclose(self) -> None:
+        self._closed = True
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+    def __repr__(self) -> str:
+        return "<httpcore.AsyncMockStream>"
+
+
+class AsyncMockBackend(AsyncNetworkBackend):
+    def __init__(self, buffer: typing.List[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: Optional[float] = None,
+        local_address: Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def sleep(self, seconds: float) -> None:
+        pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/sync.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/sync.py
index ee8f94b..7b7b417 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/sync.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/sync.py
@@ -1,178 +1,239 @@
 import socket
-import threading
-import time
-from ssl import SSLContext
-from types import TracebackType
-from typing import Optional, Type
+import ssl
+import sys
+import typing
+from functools import partial
 
 from .._exceptions import (
     ConnectError,
     ConnectTimeout,
+    ExceptionMapping,
     ReadError,
     ReadTimeout,
     WriteError,
     WriteTimeout,
     map_exceptions,
 )
-from .._types import TimeoutDict
 from .._utils import is_socket_readable
+from .base import SOCKET_OPTION, NetworkBackend, NetworkStream
 
 
-class SyncSocketStream:
+class TLSinTLSStream(NetworkStream):  # pragma: no cover
     """
-    A socket stream with read/write operations. Abstracts away any asyncio-specific
-    interfaces into a more generic base class, that we can use with alternate
-    backends, or for stand-alone test cases.
+    Because the standard `SSLContext.wrap_socket` method does
+    not work for `SSLSocket` objects, we need this class
+    to implement TLS stream using an underlying `SSLObject`
+    instance in order to support TLS on top of TLS.
     """
 
-    def __init__(self, sock: socket.socket) -> None:
-        self.sock = sock
-        self.read_lock = threading.Lock()
-        self.write_lock = threading.Lock()
-
-    def get_http_version(self) -> str:
-        selected_alpn_protocol = getattr(self.sock, "selected_alpn_protocol", None)
-        if selected_alpn_protocol is not None:
-            ident = selected_alpn_protocol()
-            return "HTTP/2" if ident == "h2" else "HTTP/1.1"
-        return "HTTP/1.1"
+    # Defined in RFC 8449
+    TLS_RECORD_SIZE = 16384
 
-    def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict
-    ) -> "SyncSocketStream":
-        connect_timeout = timeout.get("connect")
-        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+    def __init__(
+        self,
+        sock: socket.socket,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ):
+        self._sock = sock
+        self._incoming = ssl.MemoryBIO()
+        self._outgoing = ssl.MemoryBIO()
+
+        self.ssl_obj = ssl_context.wrap_bio(
+            incoming=self._incoming,
+            outgoing=self._outgoing,
+            server_hostname=server_hostname,
+        )
+
+        self._sock.settimeout(timeout)
+        self._perform_io(self.ssl_obj.do_handshake)
+
+    def _perform_io(
+        self,
+        func: typing.Callable[..., typing.Any],
+    ) -> typing.Any:
+        ret = None
 
-        with map_exceptions(exc_map):
-            self.sock.settimeout(connect_timeout)
-            wrapped = ssl_context.wrap_socket(
-                self.sock, server_hostname=hostname.decode("ascii")
-            )
+        while True:
+            errno = None
+            try:
+                ret = func()
+            except (ssl.SSLWantReadError, ssl.SSLWantWriteError) as e:
+                errno = e.errno
 
-        return SyncSocketStream(wrapped)
+            self._sock.sendall(self._outgoing.read())
 
-    def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        read_timeout = timeout.get("read")
-        exc_map = {socket.timeout: ReadTimeout, socket.error: ReadError}
+            if errno == ssl.SSL_ERROR_WANT_READ:
+                buf = self._sock.recv(self.TLS_RECORD_SIZE)
 
-        with self.read_lock:
-            with map_exceptions(exc_map):
-                self.sock.settimeout(read_timeout)
-                return self.sock.recv(n)
+                if buf:
+                    self._incoming.write(buf)
+                else:
+                    self._incoming.write_eof()
+            if errno is None:
+                return ret
 
-    def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        write_timeout = timeout.get("write")
-        exc_map = {socket.timeout: WriteTimeout, socket.error: WriteError}
+    def read(self, max_bytes: int, timeout: typing.Optional[float] = None) -> bytes:
+        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            return typing.cast(
+                bytes, self._perform_io(partial(self.ssl_obj.read, max_bytes))
+            )
 
-        with self.write_lock:
-            with map_exceptions(exc_map):
-                while data:
-                    self.sock.settimeout(write_timeout)
-                    n = self.sock.send(data)
-                    data = data[n:]
+    def write(self, buffer: bytes, timeout: typing.Optional[float] = None) -> None:
+        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            while buffer:
+                nsent = self._perform_io(partial(self.ssl_obj.write, buffer))
+                buffer = buffer[nsent:]
 
     def close(self) -> None:
-        with self.write_lock:
-            try:
-                self.sock.close()
-            except socket.error:
-                pass
-
-    def is_readable(self) -> bool:
-        return is_socket_readable(self.sock)
-
+        self._sock.close()
 
-class SyncLock:
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-
-    def __enter__(self) -> None:
-        self.acquire()
-
-    def __exit__(
+    def start_tls(
         self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        self.release()
-
-    def release(self) -> None:
-        self._lock.release()
-
-    def acquire(self) -> None:
-        self._lock.acquire()
-
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> "NetworkStream":
+        raise NotImplementedError()
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object":
+            return self.ssl_obj
+        if info == "client_addr":
+            return self._sock.getsockname()
+        if info == "server_addr":
+            return self._sock.getpeername()
+        if info == "socket":
+            return self._sock
+        if info == "is_readable":
+            return is_socket_readable(self._sock)
+        return None
+
+
+class SyncStream(NetworkStream):
+    def __init__(self, sock: socket.socket) -> None:
+        self._sock = sock
 
-class SyncSemaphore:
-    def __init__(self, max_value: int, exc_class: type) -> None:
-        self.max_value = max_value
-        self.exc_class = exc_class
-        self._semaphore = threading.Semaphore(max_value)
+    def read(self, max_bytes: int, timeout: typing.Optional[float] = None) -> bytes:
+        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            return self._sock.recv(max_bytes)
 
-    def acquire(self, timeout: float = None) -> None:
-        if not self._semaphore.acquire(timeout=timeout):  # type: ignore
-            raise self.exc_class()
+    def write(self, buffer: bytes, timeout: typing.Optional[float] = None) -> None:
+        if not buffer:
+            return
 
-    def release(self) -> None:
-        self._semaphore.release()
+        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
+        with map_exceptions(exc_map):
+            while buffer:
+                self._sock.settimeout(timeout)
+                n = self._sock.send(buffer)
+                buffer = buffer[n:]
 
+    def close(self) -> None:
+        self._sock.close()
 
-class SyncBackend:
-    def open_tcp_stream(
+    def start_tls(
         self,
-        hostname: bytes,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> NetworkStream:
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            try:
+                if isinstance(self._sock, ssl.SSLSocket):  # pragma: no cover
+                    # If the underlying socket has already been upgraded
+                    # to the TLS layer (i.e. is an instance of SSLSocket),
+                    # we need some additional smarts to support TLS-in-TLS.
+                    return TLSinTLSStream(
+                        self._sock, ssl_context, server_hostname, timeout
+                    )
+                else:
+                    self._sock.settimeout(timeout)
+                    sock = ssl_context.wrap_socket(
+                        self._sock, server_hostname=server_hostname
+                    )
+            except Exception as exc:  # pragma: nocover
+                self.close()
+                raise exc
+        return SyncStream(sock)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._sock, ssl.SSLSocket):
+            return self._sock._sslobj  # type: ignore
+        if info == "client_addr":
+            return self._sock.getsockname()
+        if info == "server_addr":
+            return self._sock.getpeername()
+        if info == "socket":
+            return self._sock
+        if info == "is_readable":
+            return is_socket_readable(self._sock)
+        return None
+
+
+class SyncBackend(NetworkBackend):
+    def connect_tcp(
+        self,
+        host: str,
         port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> SyncSocketStream:
-        address = (hostname.decode("ascii"), port)
-        connect_timeout = timeout.get("connect")
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:
+        # Note that we automatically include `TCP_NODELAY`
+        # in addition to any other custom socket options.
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
+        address = (host, port)
         source_address = None if local_address is None else (local_address, 0)
-        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
 
         with map_exceptions(exc_map):
             sock = socket.create_connection(
-                address, connect_timeout, source_address=source_address  # type: ignore
+                address,
+                timeout,
+                source_address=source_address,
             )
-            if ssl_context is not None:
-                sock = ssl_context.wrap_socket(
-                    sock, server_hostname=hostname.decode("ascii")
-                )
-            return SyncSocketStream(sock=sock)
+            for option in socket_options:
+                sock.setsockopt(*option)  # pragma: no cover
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SyncStream(sock)
 
-    def open_uds_stream(
+    def connect_unix_socket(
         self,
         path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> SyncSocketStream:
-        connect_timeout = timeout.get("connect")
-        exc_map = {socket.timeout: ConnectTimeout, socket.error: ConnectError}
+        timeout: typing.Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> NetworkStream:  # pragma: nocover
+        if sys.platform == "win32":
+            raise RuntimeError(
+                "Attempted to connect to a UNIX socket on a Windows system."
+            )
+        if socket_options is None:
+            socket_options = []
 
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
         with map_exceptions(exc_map):
             sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            sock.settimeout(connect_timeout)
+            for option in socket_options:
+                sock.setsockopt(*option)
+            sock.settimeout(timeout)
             sock.connect(path)
-
-            if ssl_context is not None:
-                sock = ssl_context.wrap_socket(
-                    sock, server_hostname=hostname.decode("ascii")
-                )
-
-            return SyncSocketStream(sock=sock)
-
-    def create_lock(self) -> SyncLock:
-        return SyncLock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> SyncSemaphore:
-        return SyncSemaphore(max_value, exc_class=exc_class)
-
-    def time(self) -> float:
-        return time.monotonic()
-
-    def sleep(self, seconds: float) -> None:
-        time.sleep(seconds)
+        return SyncStream(sock)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/trio.py b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/trio.py
index d6e67c2..b1626d2 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_backends/trio.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_backends/trio.py
@@ -1,212 +1,161 @@
-from ssl import SSLContext
-from typing import Optional
+import ssl
+import typing
 
 import trio
 
 from .._exceptions import (
     ConnectError,
     ConnectTimeout,
+    ExceptionMapping,
     ReadError,
     ReadTimeout,
     WriteError,
     WriteTimeout,
     map_exceptions,
 )
-from .._types import TimeoutDict
-from .base import AsyncBackend, AsyncLock, AsyncSemaphore, AsyncSocketStream
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
 
 
-def none_as_inf(value: Optional[float]) -> float:
-    return value if value is not None else float("inf")
-
-
-class SocketStream(AsyncSocketStream):
+class TrioStream(AsyncNetworkStream):
     def __init__(self, stream: trio.abc.Stream) -> None:
-        self.stream = stream
-        self.read_lock = trio.Lock()
-        self.write_lock = trio.Lock()
+        self._stream = stream
+
+    async def read(
+        self, max_bytes: int, timeout: typing.Optional[float] = None
+    ) -> bytes:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: ReadTimeout,
+            trio.BrokenResourceError: ReadError,
+            trio.ClosedResourceError: ReadError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                data: bytes = await self._stream.receive_some(max_bytes=max_bytes)
+                return data
+
+    async def write(
+        self, buffer: bytes, timeout: typing.Optional[float] = None
+    ) -> None:
+        if not buffer:
+            return
 
-    def get_http_version(self) -> str:
-        if not isinstance(self.stream, trio.SSLStream):
-            return "HTTP/1.1"
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: WriteTimeout,
+            trio.BrokenResourceError: WriteError,
+            trio.ClosedResourceError: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                await self._stream.send_all(data=buffer)
 
-        ident = self.stream.selected_alpn_protocol()
-        return "HTTP/2" if ident == "h2" else "HTTP/1.1"
+    async def aclose(self) -> None:
+        await self._stream.aclose()
 
     async def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict
-    ) -> "SocketStream":
-        connect_timeout = none_as_inf(timeout.get("connect"))
-        exc_map = {
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: typing.Optional[str] = None,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncNetworkStream:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
             trio.TooSlowError: ConnectTimeout,
             trio.BrokenResourceError: ConnectError,
         }
         ssl_stream = trio.SSLStream(
-            self.stream,
+            self._stream,
             ssl_context=ssl_context,
-            server_hostname=hostname.decode("ascii"),
+            server_hostname=server_hostname,
+            https_compatible=True,
+            server_side=False,
         )
-
         with map_exceptions(exc_map):
-            with trio.fail_after(connect_timeout):
-                await ssl_stream.do_handshake()
-            return SocketStream(ssl_stream)
-
-    async def read(self, n: int, timeout: TimeoutDict) -> bytes:
-        read_timeout = none_as_inf(timeout.get("read"))
-        exc_map = {trio.TooSlowError: ReadTimeout, trio.BrokenResourceError: ReadError}
-
-        async with self.read_lock:
-            with map_exceptions(exc_map):
-                try:
-                    with trio.fail_after(read_timeout):
-                        return await self.stream.receive_some(max_bytes=n)
-                except trio.TooSlowError as exc:
-                    await self.stream.aclose()
-                    raise exc
-
-    async def write(self, data: bytes, timeout: TimeoutDict) -> None:
-        if not data:
-            return
-
-        write_timeout = none_as_inf(timeout.get("write"))
-        exc_map = {
-            trio.TooSlowError: WriteTimeout,
-            trio.BrokenResourceError: WriteError,
-        }
-
-        async with self.write_lock:
-            with map_exceptions(exc_map):
-                try:
-                    with trio.fail_after(write_timeout):
-                        return await self.stream.send_all(data)
-                except trio.TooSlowError as exc:
-                    await self.stream.aclose()
-                    raise exc
-
-    async def aclose(self) -> None:
-        async with self.write_lock:
             try:
-                await self.stream.aclose()
-            except trio.BrokenResourceError:
-                pass
-
-    def is_readable(self) -> bool:
-        # Adapted from: https://github.com/encode/httpx/pull/143#issuecomment-515202982
-        stream = self.stream
-
-        # Peek through any SSLStream wrappers to get the underlying SocketStream.
+                with trio.fail_after(timeout_or_inf):
+                    await ssl_stream.do_handshake()
+            except Exception as exc:  # pragma: nocover
+                await self.aclose()
+                raise exc
+        return TrioStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._stream, trio.SSLStream):
+            # Type checkers cannot see `_ssl_object` attribute because trio._ssl.SSLStream uses __getattr__/__setattr__.
+            # Tracked at https://github.com/python-trio/trio/issues/542
+            return self._stream._ssl_object  # type: ignore[attr-defined]
+        if info == "client_addr":
+            return self._get_socket_stream().socket.getsockname()
+        if info == "server_addr":
+            return self._get_socket_stream().socket.getpeername()
+        if info == "socket":
+            stream = self._stream
+            while isinstance(stream, trio.SSLStream):
+                stream = stream.transport_stream
+            assert isinstance(stream, trio.SocketStream)
+            return stream.socket
+        if info == "is_readable":
+            socket = self.get_extra_info("socket")
+            return socket.is_readable()
+        return None
+
+    def _get_socket_stream(self) -> trio.SocketStream:
+        stream = self._stream
         while isinstance(stream, trio.SSLStream):
             stream = stream.transport_stream
         assert isinstance(stream, trio.SocketStream)
-
-        return stream.socket.is_readable()
+        return stream
 
 
-class Lock(AsyncLock):
-    def __init__(self) -> None:
-        self._lock = trio.Lock()
-
-    async def release(self) -> None:
-        self._lock.release()
-
-    async def acquire(self) -> None:
-        await self._lock.acquire()
-
-
-class Semaphore(AsyncSemaphore):
-    def __init__(self, max_value: int, exc_class: type):
-        self.max_value = max_value
-        self.exc_class = exc_class
-
-    @property
-    def semaphore(self) -> trio.Semaphore:
-        if not hasattr(self, "_semaphore"):
-            self._semaphore = trio.Semaphore(self.max_value, max_value=self.max_value)
-        return self._semaphore
-
-    async def acquire(self, timeout: float = None) -> None:
-        timeout = none_as_inf(timeout)
-
-        with trio.move_on_after(timeout):
-            await self.semaphore.acquire()
-            return
-
-        raise self.exc_class()
-
-    async def release(self) -> None:
-        self.semaphore.release()
-
-
-class TrioBackend(AsyncBackend):
-    async def open_tcp_stream(
+class TrioBackend(AsyncNetworkBackend):
+    async def connect_tcp(
         self,
-        hostname: bytes,
+        host: str,
         port: int,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-        *,
-        local_address: Optional[str],
-    ) -> AsyncSocketStream:
-        connect_timeout = none_as_inf(timeout.get("connect"))
-        # Trio will support local_address from 0.16.1 onwards.
-        # We only include the keyword argument if a local_address
-        #  argument has been passed.
-        kwargs: dict = {} if local_address is None else {"local_address": local_address}
-        exc_map = {
-            OSError: ConnectError,
+        timeout: typing.Optional[float] = None,
+        local_address: typing.Optional[str] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:
+        # By default for TCP sockets, trio enables TCP_NODELAY.
+        # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
             trio.TooSlowError: ConnectTimeout,
             trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
         }
-
         with map_exceptions(exc_map):
-            with trio.fail_after(connect_timeout):
+            with trio.fail_after(timeout_or_inf):
                 stream: trio.abc.Stream = await trio.open_tcp_stream(
-                    hostname, port, **kwargs
+                    host=host, port=port, local_address=local_address
                 )
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return TrioStream(stream)
 
-                if ssl_context is not None:
-                    stream = trio.SSLStream(
-                        stream, ssl_context, server_hostname=hostname.decode("ascii")
-                    )
-                    await stream.do_handshake()
-
-                return SocketStream(stream=stream)
-
-    async def open_uds_stream(
+    async def connect_unix_socket(
         self,
         path: str,
-        hostname: bytes,
-        ssl_context: Optional[SSLContext],
-        timeout: TimeoutDict,
-    ) -> AsyncSocketStream:
-        connect_timeout = none_as_inf(timeout.get("connect"))
-        exc_map = {
-            OSError: ConnectError,
+        timeout: typing.Optional[float] = None,
+        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
+    ) -> AsyncNetworkStream:  # pragma: nocover
+        if socket_options is None:
+            socket_options = []
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
             trio.TooSlowError: ConnectTimeout,
             trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
         }
-
         with map_exceptions(exc_map):
-            with trio.fail_after(connect_timeout):
+            with trio.fail_after(timeout_or_inf):
                 stream: trio.abc.Stream = await trio.open_unix_socket(path)
-
-                if ssl_context is not None:
-                    stream = trio.SSLStream(
-                        stream, ssl_context, server_hostname=hostname.decode("ascii")
-                    )
-                    await stream.do_handshake()
-
-                return SocketStream(stream=stream)
-
-    def create_lock(self) -> AsyncLock:
-        return Lock()
-
-    def create_semaphore(self, max_value: int, exc_class: type) -> AsyncSemaphore:
-        return Semaphore(max_value, exc_class=exc_class)
-
-    async def time(self) -> float:
-        return trio.current_time()
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return TrioStream(stream)
 
     async def sleep(self, seconds: float) -> None:
-        await trio.sleep(seconds)
+        await trio.sleep(seconds)  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_bytestreams.py b/addon/globalPlugins/spellcheck/libs/httpcore/_bytestreams.py
deleted file mode 100644
index 317f411..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_bytestreams.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from typing import AsyncIterator, Callable, Iterator
-
-from ._async.base import AsyncByteStream
-from ._sync.base import SyncByteStream
-
-
-class ByteStream(AsyncByteStream, SyncByteStream):
-    """
-    A concrete implementation for either sync or async byte streams.
-
-    Example::
-
-        stream = httpcore.ByteStream(b"123")
-
-    Parameters
-    ----------
-    content:
-        A plain byte string used as the content of the stream.
-    """
-
-    def __init__(self, content: bytes) -> None:
-        self._content = content
-
-    def __iter__(self) -> Iterator[bytes]:
-        yield self._content
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        yield self._content
-
-
-class IteratorByteStream(SyncByteStream):
-    """
-    A concrete implementation for sync byte streams.
-
-    Example::
-
-        def generate_content():
-            yield b"Hello, world!"
-            ...
-
-        stream = httpcore.IteratorByteStream(generate_content())
-
-    Parameters
-    ----------
-    iterator:
-        A sync byte iterator, used as the content of the stream.
-    close_func:
-        An optional function called when closing the stream.
-    """
-
-    def __init__(self, iterator: Iterator[bytes], close_func: Callable = None) -> None:
-        self._iterator = iterator
-        self._close_func = close_func
-
-    def __iter__(self) -> Iterator[bytes]:
-        for chunk in self._iterator:
-            yield chunk
-
-    def close(self) -> None:
-        if self._close_func is not None:
-            self._close_func()
-
-
-class AsyncIteratorByteStream(AsyncByteStream):
-    """
-    A concrete implementation for async byte streams.
-
-    Example::
-
-        async def generate_content():
-            yield b"Hello, world!"
-            ...
-
-        stream = httpcore.AsyncIteratorByteStream(generate_content())
-
-    Parameters
-    ----------
-    aiterator:
-        An async byte iterator, used as the content of the stream.
-    aclose_func:
-        An optional async function called when closing the stream.
-    """
-
-    def __init__(
-        self, aiterator: AsyncIterator[bytes], aclose_func: Callable = None
-    ) -> None:
-        self._aiterator = aiterator
-        self._aclose_func = aclose_func
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        async for chunk in self._aiterator:
-            yield chunk
-
-    async def aclose(self) -> None:
-        if self._aclose_func is not None:
-            await self._aclose_func()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_exceptions.py b/addon/globalPlugins/spellcheck/libs/httpcore/_exceptions.py
index ba56829..81e7fc6 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_exceptions.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_exceptions.py
@@ -1,16 +1,26 @@
 import contextlib
-from typing import Dict, Iterator, Type
+from typing import Iterator, Mapping, Type
+
+ExceptionMapping = Mapping[Type[Exception], Type[Exception]]
 
 
 @contextlib.contextmanager
-def map_exceptions(map: Dict[Type[Exception], Type[Exception]]) -> Iterator[None]:
+def map_exceptions(map: ExceptionMapping) -> Iterator[None]:
     try:
         yield
     except Exception as exc:  # noqa: PIE786
         for from_exc, to_exc in map.items():
             if isinstance(exc, from_exc):
-                raise to_exc(exc) from None
-        raise
+                raise to_exc(exc) from exc
+        raise  # pragma: nocover
+
+
+class ConnectionNotAvailable(Exception):
+    pass
+
+
+class ProxyError(Exception):
+    pass
 
 
 class UnsupportedProtocol(Exception):
@@ -29,10 +39,6 @@ class LocalProtocolError(ProtocolError):
     pass
 
 
-class ProxyError(Exception):
-    pass
-
-
 # Timeout errors
 
 
@@ -73,7 +79,3 @@ class ReadError(NetworkError):
 
 class WriteError(NetworkError):
     pass
-
-
-class CloseError(NetworkError):
-    pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_models.py b/addon/globalPlugins/spellcheck/libs/httpcore/_models.py
new file mode 100644
index 0000000..397bd75
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_models.py
@@ -0,0 +1,492 @@
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+from urllib.parse import urlparse
+
+# Functions for typechecking...
+
+
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
+HeaderTypes = Union[HeadersAsSequence, HeadersAsMapping, None]
+
+Extensions = MutableMapping[str, Any]
+
+
+def enforce_bytes(value: Union[bytes, str], *, name: str) -> bytes:
+    """
+    Any arguments that are ultimately represented as bytes can be specified
+    either as bytes or as strings.
+
+    However we enforce that any string arguments must only contain characters in
+    the plain ASCII range. chr(0)...chr(127). If you need to use characters
+    outside that range then be precise, and use a byte-wise argument.
+    """
+    if isinstance(value, str):
+        try:
+            return value.encode("ascii")
+        except UnicodeEncodeError:
+            raise TypeError(f"{name} strings may not include unicode characters.")
+    elif isinstance(value, bytes):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be bytes or str, but got {seen_type}.")
+
+
+def enforce_url(value: Union["URL", bytes, str], *, name: str) -> "URL":
+    """
+    Type check for URL parameters.
+    """
+    if isinstance(value, (bytes, str)):
+        return URL(value)
+    elif isinstance(value, URL):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be a URL, bytes, or str, but got {seen_type}.")
+
+
+def enforce_headers(
+    value: Union[HeadersAsMapping, HeadersAsSequence, None] = None, *, name: str
+) -> List[Tuple[bytes, bytes]]:
+    """
+    Convienence function that ensure all items in request or response headers
+    are either bytes or strings in the plain ASCII range.
+    """
+    if value is None:
+        return []
+    elif isinstance(value, Mapping):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value.items()
+        ]
+    elif isinstance(value, Sequence):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value
+        ]
+
+    seen_type = type(value).__name__
+    raise TypeError(
+        f"{name} must be a mapping or sequence of two-tuples, but got {seen_type}."
+    )
+
+
+def enforce_stream(
+    value: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None], *, name: str
+) -> Union[Iterable[bytes], AsyncIterable[bytes]]:
+    if value is None:
+        return ByteStream(b"")
+    elif isinstance(value, bytes):
+        return ByteStream(value)
+    return value
+
+
+# * https://tools.ietf.org/html/rfc3986#section-3.2.3
+# * https://url.spec.whatwg.org/#url-miscellaneous
+# * https://url.spec.whatwg.org/#scheme-state
+DEFAULT_PORTS = {
+    b"ftp": 21,
+    b"http": 80,
+    b"https": 443,
+    b"ws": 80,
+    b"wss": 443,
+}
+
+
+def include_request_headers(
+    headers: List[Tuple[bytes, bytes]],
+    *,
+    url: "URL",
+    content: Union[None, bytes, Iterable[bytes], AsyncIterable[bytes]],
+) -> List[Tuple[bytes, bytes]]:
+    headers_set = set(k.lower() for k, v in headers)
+
+    if b"host" not in headers_set:
+        default_port = DEFAULT_PORTS.get(url.scheme)
+        if url.port is None or url.port == default_port:
+            header_value = url.host
+        else:
+            header_value = b"%b:%d" % (url.host, url.port)
+        headers = [(b"Host", header_value)] + headers
+
+    if (
+        content is not None
+        and b"content-length" not in headers_set
+        and b"transfer-encoding" not in headers_set
+    ):
+        if isinstance(content, bytes):
+            content_length = str(len(content)).encode("ascii")
+            headers += [(b"Content-Length", content_length)]
+        else:
+            headers += [(b"Transfer-Encoding", b"chunked")]  # pragma: nocover
+
+    return headers
+
+
+# Interfaces for byte streams...
+
+
+class ByteStream:
+    """
+    A container for non-streaming content, and that supports both sync and async
+    stream iteration.
+    """
+
+    def __init__(self, content: bytes) -> None:
+        self._content = content
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield self._content
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{len(self._content)} bytes]>"
+
+
+class Origin:
+    def __init__(self, scheme: bytes, host: bytes, port: int) -> None:
+        self.scheme = scheme
+        self.host = host
+        self.port = port
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, Origin)
+            and self.scheme == other.scheme
+            and self.host == other.host
+            and self.port == other.port
+        )
+
+    def __str__(self) -> str:
+        scheme = self.scheme.decode("ascii")
+        host = self.host.decode("ascii")
+        port = str(self.port)
+        return f"{scheme}://{host}:{port}"
+
+
+class URL:
+    """
+    Represents the URL against which an HTTP request may be made.
+
+    The URL may either be specified as a plain string, for convienence:
+
+    ```python
+    url = httpcore.URL("https://www.example.com/")
+    ```
+
+    Or be constructed with explicitily pre-parsed components:
+
+    ```python
+    url = httpcore.URL(scheme=b'https', host=b'www.example.com', port=None, target=b'/')
+    ```
+
+    Using this second more explicit style allows integrations that are using
+    `httpcore` to pass through URLs that have already been parsed in order to use
+    libraries such as `rfc-3986` rather than relying on the stdlib. It also ensures
+    that URL parsing is treated identically at both the networking level and at any
+    higher layers of abstraction.
+
+    The four components are important here, as they allow the URL to be precisely
+    specified in a pre-parsed format. They also allow certain types of request to
+    be created that could not otherwise be expressed.
+
+    For example, an HTTP request to `http://www.example.com/` forwarded via a proxy
+    at `http://localhost:8080`...
+
+    ```python
+    # Constructs an HTTP request with a complete URL as the target:
+    # GET https://www.example.com/ HTTP/1.1
+    url = httpcore.URL(
+        scheme=b'http',
+        host=b'localhost',
+        port=8080,
+        target=b'https://www.example.com/'
+    )
+    request = httpcore.Request(
+        method="GET",
+        url=url
+    )
+    ```
+
+    Another example is constructing an `OPTIONS *` request...
+
+    ```python
+    # Constructs an 'OPTIONS *' HTTP request:
+    # OPTIONS * HTTP/1.1
+    url = httpcore.URL(scheme=b'https', host=b'www.example.com', target=b'*')
+    request = httpcore.Request(method="OPTIONS", url=url)
+    ```
+
+    This kind of request is not possible to formulate with a URL string,
+    because the `/` delimiter is always used to demark the target from the
+    host/port portion of the URL.
+
+    For convenience, string-like arguments may be specified either as strings or
+    as bytes. However, once a request is being issue over-the-wire, the URL
+    components are always ultimately required to be a bytewise representation.
+
+    In order to avoid any ambiguity over character encodings, when strings are used
+    as arguments, they must be strictly limited to the ASCII range `chr(0)`-`chr(127)`.
+    If you require a bytewise representation that is outside this range you must
+    handle the character encoding directly, and pass a bytes instance.
+    """
+
+    def __init__(
+        self,
+        url: Union[bytes, str] = "",
+        *,
+        scheme: Union[bytes, str] = b"",
+        host: Union[bytes, str] = b"",
+        port: Optional[int] = None,
+        target: Union[bytes, str] = b"",
+    ) -> None:
+        """
+        Parameters:
+            url: The complete URL as a string or bytes.
+            scheme: The URL scheme as a string or bytes.
+                Typically either `"http"` or `"https"`.
+            host: The URL host as a string or bytes. Such as `"www.example.com"`.
+            port: The port to connect to. Either an integer or `None`.
+            target: The target of the HTTP request. Such as `"/items?search=red"`.
+        """
+        if url:
+            parsed = urlparse(enforce_bytes(url, name="url"))
+            self.scheme = parsed.scheme
+            self.host = parsed.hostname or b""
+            self.port = parsed.port
+            self.target = (parsed.path or b"/") + (
+                b"?" + parsed.query if parsed.query else b""
+            )
+        else:
+            self.scheme = enforce_bytes(scheme, name="scheme")
+            self.host = enforce_bytes(host, name="host")
+            self.port = port
+            self.target = enforce_bytes(target, name="target")
+
+    @property
+    def origin(self) -> Origin:
+        default_port = {
+            b"http": 80,
+            b"https": 443,
+            b"ws": 80,
+            b"wss": 443,
+            b"socks5": 1080,
+        }[self.scheme]
+        return Origin(
+            scheme=self.scheme, host=self.host, port=self.port or default_port
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, URL)
+            and other.scheme == self.scheme
+            and other.host == self.host
+            and other.port == self.port
+            and other.target == self.target
+        )
+
+    def __bytes__(self) -> bytes:
+        if self.port is None:
+            return b"%b://%b%b" % (self.scheme, self.host, self.target)
+        return b"%b://%b:%d%b" % (self.scheme, self.host, self.port, self.target)
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(scheme={self.scheme!r}, "
+            f"host={self.host!r}, port={self.port!r}, target={self.target!r})"
+        )
+
+
+class Request:
+    """
+    An HTTP request.
+    """
+
+    def __init__(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> None:
+        """
+        Parameters:
+            method: The HTTP request method, either as a string or bytes.
+                For example: `GET`.
+            url: The request URL, either as a `URL` instance, or as a string or bytes.
+                For example: `"https://www.example.com".`
+            headers: The HTTP request headers.
+            content: The content of the response body.
+            extensions: A dictionary of optional extra information included on
+                the request. Possible keys include `"timeout"`, and `"trace"`.
+        """
+        self.method: bytes = enforce_bytes(method, name="method")
+        self.url: URL = enforce_url(url, name="url")
+        self.headers: List[Tuple[bytes, bytes]] = enforce_headers(
+            headers, name="headers"
+        )
+        self.stream: Union[Iterable[bytes], AsyncIterable[bytes]] = enforce_stream(
+            content, name="content"
+        )
+        self.extensions = {} if extensions is None else extensions
+
+        if "target" in self.extensions:
+            self.url = URL(
+                scheme=self.url.scheme,
+                host=self.url.host,
+                port=self.url.port,
+                target=self.extensions["target"],
+            )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.method!r}]>"
+
+
+class Response:
+    """
+    An HTTP response.
+    """
+
+    def __init__(
+        self,
+        status: int,
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, Iterable[bytes], AsyncIterable[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> None:
+        """
+        Parameters:
+            status: The HTTP status code of the response. For example `200`.
+            headers: The HTTP response headers.
+            content: The content of the response body.
+            extensions: A dictionary of optional extra information included on
+                the responseself.Possible keys include `"http_version"`,
+                `"reason_phrase"`, and `"network_stream"`.
+        """
+        self.status: int = status
+        self.headers: List[Tuple[bytes, bytes]] = enforce_headers(
+            headers, name="headers"
+        )
+        self.stream: Union[Iterable[bytes], AsyncIterable[bytes]] = enforce_stream(
+            content, name="content"
+        )
+        self.extensions = {} if extensions is None else extensions
+
+        self._stream_consumed = False
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            if isinstance(self.stream, Iterable):
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. "
+                    "Call 'response.read()' first."
+                )
+            else:
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. "
+                    "Call 'await response.aread()' first."
+                )
+        return self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.status}]>"
+
+    # Sync interface...
+
+    def read(self) -> bytes:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to read an asynchronous response using 'response.read()'. "
+                "You should use 'await response.aread()' instead."
+            )
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part for part in self.iter_stream()])
+        return self._content
+
+    def iter_stream(self) -> Iterator[bytes]:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to stream an asynchronous response using 'for ... in "
+                "response.iter_stream()'. "
+                "You should use 'async for ... in response.aiter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError(
+                "Attempted to call 'for ... in response.iter_stream()' more than once."
+            )
+        self._stream_consumed = True
+        for chunk in self.stream:
+            yield chunk
+
+    def close(self) -> None:
+        if not isinstance(self.stream, Iterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to close an asynchronous response using 'response.close()'. "
+                "You should use 'await response.aclose()' instead."
+            )
+        if hasattr(self.stream, "close"):
+            self.stream.close()
+
+    # Async interface...
+
+    async def aread(self) -> bytes:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to read an synchronous response using "
+                "'await response.aread()'. "
+                "You should use 'response.read()' instead."
+            )
+        if not hasattr(self, "_content"):
+            self._content = b"".join([part async for part in self.aiter_stream()])
+        return self._content
+
+    async def aiter_stream(self) -> AsyncIterator[bytes]:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to stream an synchronous response using 'async for ... in "
+                "response.aiter_stream()'. "
+                "You should use 'for ... in response.iter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError(
+                "Attempted to call 'async for ... in response.aiter_stream()' "
+                "more than once."
+            )
+        self._stream_consumed = True
+        async for chunk in self.stream:
+            yield chunk
+
+    async def aclose(self) -> None:
+        if not isinstance(self.stream, AsyncIterable):  # pragma: nocover
+            raise RuntimeError(
+                "Attempted to close a synchronous response using "
+                "'await response.aclose()'. "
+                "You should use 'response.close()' instead."
+            )
+        if hasattr(self.stream, "aclose"):
+            await self.stream.aclose()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_ssl.py b/addon/globalPlugins/spellcheck/libs/httpcore/_ssl.py
new file mode 100644
index 0000000..c99c5a6
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_ssl.py
@@ -0,0 +1,9 @@
+import ssl
+
+import certifi
+
+
+def default_ssl_context() -> ssl.SSLContext:
+    context = ssl.create_default_context()
+    context.load_verify_locations(certifi.where())
+    return context
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/__init__.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/__init__.py
index e69de29..b476d76 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/__init__.py
@@ -0,0 +1,39 @@
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .http_proxy import HTTPProxy
+from .interfaces import ConnectionInterface
+
+try:
+    from .http2 import HTTP2Connection
+except ImportError:  # pragma: nocover
+
+    class HTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import SOCKSProxy
+except ImportError:  # pragma: nocover
+
+    class SOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+]
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/base.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/base.py
deleted file mode 100644
index 45ef4ab..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/base.py
+++ /dev/null
@@ -1,122 +0,0 @@
-import enum
-from types import TracebackType
-from typing import Iterator, Tuple, Type
-
-from .._types import URL, Headers, T
-
-
-class NewConnectionRequired(Exception):
-    pass
-
-
-class ConnectionState(enum.IntEnum):
-    """
-    PENDING  READY
-        |    |   ^
-        v    V   |
-        ACTIVE   |
-         |  |    |
-         |  V    |
-         V  IDLE-+
-       FULL   |
-         |    |
-         V    V
-         CLOSED
-    """
-
-    PENDING = 0  # Connection not yet acquired.
-    READY = 1  # Re-acquired from pool, about to send a request.
-    ACTIVE = 2  # Active requests.
-    FULL = 3  # Active requests, no more stream IDs available.
-    IDLE = 4  # No active requests.
-    CLOSED = 5  # Connection closed.
-
-
-class SyncByteStream:
-    """
-    The base interface for request and response bodies.
-
-    Concrete implementations should subclass this class, and implement
-    the :meth:`__iter__` method, and optionally the :meth:`close` method.
-    """
-
-    def __iter__(self) -> Iterator[bytes]:
-        """
-        Yield bytes representing the request or response body.
-        """
-        yield b""  # pragma: nocover
-
-    def close(self) -> None:
-        """
-        Must be called by the client to indicate that the stream has been closed.
-        """
-        pass  # pragma: nocover
-
-    def read(self) -> bytes:
-        try:
-            return b"".join([part for part in self])
-        finally:
-            self.close()
-
-
-class SyncHTTPTransport:
-    """
-    The base interface for sending HTTP requests.
-
-    Concrete implementations should subclass this class, and implement
-    the :meth:`handle_request` method, and optionally the :meth:`close` method.
-    """
-
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        """
-        The interface for sending a single HTTP request, and returning a response.
-
-        Parameters
-        ----------
-        method:
-            The HTTP method, such as ``b'GET'``.
-        url:
-            The URL as a 4-tuple of (scheme, host, port, path).
-        headers:
-            Any HTTP headers to send with the request.
-        stream:
-            The body of the HTTP request.
-        extensions:
-            A dictionary of optional extensions.
-
-        Returns
-        -------
-        status_code:
-            The HTTP status code, such as ``200``.
-        headers:
-            Any HTTP headers included on the response.
-        stream:
-            The body of the HTTP response.
-        extensions:
-            A dictionary of optional extensions.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def close(self) -> None:
-        """
-        Close the implementation, which should close any outstanding response streams,
-        and any keep alive connections.
-        """
-
-    def __enter__(self: T) -> T:
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        self.close()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection.py
index 9127b08..c3890f3 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection.py
@@ -1,156 +1,109 @@
-from ssl import SSLContext
-from typing import List, Optional, Tuple, cast
-
-from .._backends.sync import SyncBackend, SyncLock, SyncSocketStream, SyncBackend
+import itertools
+import logging
+import ssl
+from types import TracebackType
+from typing import Iterable, Iterator, Optional, Type
+
+from .._backends.sync import SyncBackend
+from .._backends.base import SOCKET_OPTION, NetworkBackend, NetworkStream
 from .._exceptions import ConnectError, ConnectTimeout
-from .._types import URL, Headers, Origin, TimeoutDict
-from .._utils import exponential_backoff, get_logger, url_to_origin
-from .base import SyncByteStream, SyncHTTPTransport, NewConnectionRequired
-from .http import SyncBaseHTTPConnection
-from .http11 import SyncHTTP11Connection
-
-logger = get_logger(__name__)
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
 
 RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
 
 
-class SyncHTTPConnection(SyncHTTPTransport):
+logger = logging.getLogger("httpcore.connection")
+
+
+def exponential_backoff(factor: float) -> Iterator[float]:
+    """
+    Generate a geometric sequence that has a ratio of 2 and starts with 0.
+
+    For example:
+    - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...`
+    - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...`
+    """
+    yield 0
+    for n in itertools.count():
+        yield factor * 2**n
+
+
+class HTTPConnection(ConnectionInterface):
     def __init__(
         self,
         origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        keepalive_expiry: Optional[float] = None,
         http1: bool = True,
         http2: bool = False,
-        keepalive_expiry: float = None,
-        uds: str = None,
-        ssl_context: SSLContext = None,
-        socket: SyncSocketStream = None,
-        local_address: str = None,
         retries: int = 0,
-        backend: SyncBackend = None,
-    ):
-        self.origin = origin
-        self._http1_enabled = http1
-        self._http2_enabled = http2
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
         self._keepalive_expiry = keepalive_expiry
-        self._uds = uds
-        self._ssl_context = SSLContext() if ssl_context is None else ssl_context
-        self.socket = socket
-        self._local_address = local_address
+        self._http1 = http1
+        self._http2 = http2
         self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
 
-        alpn_protocols: List[str] = []
-        if http1:
-            alpn_protocols.append("http/1.1")
-        if http2:
-            alpn_protocols.append("h2")
-
-        self._ssl_context.set_alpn_protocols(alpn_protocols)
-
-        self.connection: Optional[SyncBaseHTTPConnection] = None
-        self._is_http11 = False
-        self._is_http2 = False
-        self._connect_failed = False
-        self._expires_at: Optional[float] = None
-        self._backend = SyncBackend() if backend is None else backend
-
-    def __repr__(self) -> str:
-        return f"<SyncHTTPConnection [{self.info()}]>"
-
-    def info(self) -> str:
-        if self.connection is None:
-            return "Connection failed" if self._connect_failed else "Connecting"
-        return self.connection.info()
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        This occurs when any of the following occur:
-
-        * There are no active requests on an HTTP/1.1 connection, and the underlying
-          socket is readable. The only valid state the socket can be readable in
-          if this occurs is when the b"" EOF marker is about to be returned,
-          indicating a server disconnect.
-        * There are no active requests being made and the keepalive timeout has passed.
-        """
-        if self.connection is None:
-            return False
-        return self.connection.should_close()
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        if self.connection is None:
-            return False
-        return self.connection.is_idle()
+        self._network_backend: NetworkBackend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+        self._connection: Optional[ConnectionInterface] = None
+        self._connect_failed: bool = False
+        self._request_lock = Lock()
+        self._socket_options = socket_options
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection to {self._origin}"
+            )
 
-    def is_closed(self) -> bool:
-        if self.connection is None:
-            return self._connect_failed
-        return self.connection.is_closed()
+        try:
+            with self._request_lock:
+                if self._connection is None:
+                    stream = self._connect(request)
 
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        This occurs when any of the following occur:
-
-        * The connection has not yet been opened, and HTTP/2 support is enabled.
-          We don't *know* at this point if we'll end up on an HTTP/2 connection or
-          not, but we *might* do, so we indicate availability.
-        * The connection has been opened, and is currently idle.
-        * The connection is open, and is an HTTP/2 connection. The connection must
-          also not currently be exceeding the maximum number of allowable concurrent
-          streams and must not have exhausted the maximum total number of stream IDs.
-        """
-        if self.connection is None:
-            return self._http2_enabled and not self.is_closed
-        return self.connection.is_available()
-
-    @property
-    def request_lock(self) -> SyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_request_lock"):
-            self._request_lock = self._backend.create_lock()
-        return self._request_lock
-
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        assert url_to_origin(url) == self.origin
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        with self.request_lock:
-            if self.connection is None:
-                if self._connect_failed:
-                    raise NewConnectionRequired()
-                if not self.socket:
-                    logger.trace(
-                        "open_socket origin=%r timeout=%r", self.origin, timeout
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
                     )
-                    self.socket = self._open_socket(timeout)
-                self._create_connection(self.socket)
-            elif not self.connection.is_available():
-                raise NewConnectionRequired()
-
-        assert self.connection is not None
-        logger.trace(
-            "connection.handle_request method=%r url=%r headers=%r",
-            method,
-            url,
-            headers,
-        )
-        return self.connection.handle_request(method, url, headers, stream, extensions)
-
-    def _open_socket(self, timeout: TimeoutDict = None) -> SyncSocketStream:
-        scheme, hostname, port = self.origin
-        timeout = {} if timeout is None else timeout
-        ssl_context = self._ssl_context if scheme == b"https" else None
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+        except BaseException as exc:
+            self._connect_failed = True
+            raise exc
+
+        return self._connection.handle_request(request)
+
+    def _connect(self, request: Request) -> NetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
 
         retries_left = self._retries
         delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
@@ -158,59 +111,110 @@ def _open_socket(self, timeout: TimeoutDict = None) -> SyncSocketStream:
         while True:
             try:
                 if self._uds is None:
-                    return self._backend.open_tcp_stream(
-                        hostname,
-                        port,
-                        ssl_context,
-                        timeout,
-                        local_address=self._local_address,
-                    )
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
                 else:
-                    return self._backend.open_uds_stream(
-                        self._uds, hostname, ssl_context, timeout
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    with Trace(
+                        "connect_unix_socket", logger, request, kwargs
+                    ) as trace:
+                        stream = self._network_backend.connect_unix_socket(
+                            **kwargs
+                        )
+                        trace.return_value = stream
+
+                if self._origin.scheme in (b"https", b"wss"):
+                    ssl_context = (
+                        default_ssl_context()
+                        if self._ssl_context is None
+                        else self._ssl_context
                     )
+                    alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                    ssl_context.set_alpn_protocols(alpn_protocols)
+
+                    kwargs = {
+                        "ssl_context": ssl_context,
+                        "server_hostname": sni_hostname
+                        or self._origin.host.decode("ascii"),
+                        "timeout": timeout,
+                    }
+                    with Trace("start_tls", logger, request, kwargs) as trace:
+                        stream = stream.start_tls(**kwargs)
+                        trace.return_value = stream
+                return stream
             except (ConnectError, ConnectTimeout):
                 if retries_left <= 0:
-                    self._connect_failed = True
                     raise
                 retries_left -= 1
                 delay = next(delays)
-                self._backend.sleep(delay)
-            except Exception:  # noqa: PIE786
-                self._connect_failed = True
-                raise
-
-    def _create_connection(self, socket: SyncSocketStream) -> None:
-        http_version = socket.get_http_version()
-        logger.trace(
-            "create_connection socket=%r http_version=%r", socket, http_version
-        )
-        if http_version == "HTTP/2" or (
-            self._http2_enabled and not self._http1_enabled
-        ):
-            from .http2 import SyncHTTP2Connection
-
-            self._is_http2 = True
-            self.connection = SyncHTTP2Connection(
-                socket=socket,
-                keepalive_expiry=self._keepalive_expiry,
-                backend=self._backend,
-            )
-        else:
-            self._is_http11 = True
-            self.connection = SyncHTTP11Connection(
-                socket=socket, keepalive_expiry=self._keepalive_expiry
-            )
+                with Trace("retry", logger, request, kwargs) as trace:
+                    self._network_backend.sleep(delay)
 
-    def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> None:
-        if self.connection is not None:
-            logger.trace("start_tls hostname=%r timeout=%r", hostname, timeout)
-            self.socket = self.connection.start_tls(hostname, ssl_context, timeout)
-            logger.trace("start_tls complete hostname=%r timeout=%r", hostname, timeout)
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
 
     def close(self) -> None:
-        with self.request_lock:
-            if self.connection is not None:
-                self.connection.close()
+        if self._connection is not None:
+            with Trace("close", logger, None, {}):
+                self._connection.close()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTPConnection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection_pool.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection_pool.py
index 0060280..8dcf348 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection_pool.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/connection_pool.py
@@ -1,360 +1,380 @@
-import warnings
-from ssl import SSLContext
-from typing import (
-    Iterator,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
-
-from .._backends.sync import SyncBackend, SyncLock, SyncSemaphore
-from .._backends.base import lookup_sync_backend
-from .._exceptions import LocalProtocolError, PoolTimeout, UnsupportedProtocol
-from .._threadlock import ThreadLock
-from .._types import URL, Headers, Origin, TimeoutDict
-from .._utils import get_logger, origin_to_url_string, url_to_origin
-from .base import SyncByteStream, SyncHTTPTransport, NewConnectionRequired
-from .connection import SyncHTTPConnection
-
-logger = get_logger(__name__)
-
-
-class NullSemaphore(SyncSemaphore):
-    def __init__(self) -> None:
-        pass
-
-    def acquire(self, timeout: float = None) -> None:
-        return
-
-    def release(self) -> None:
-        return
-
-
-class ResponseByteStream(SyncByteStream):
-    def __init__(
-        self,
-        stream: SyncByteStream,
-        connection: SyncHTTPConnection,
-        callback: Callable,
+import ssl
+import sys
+from types import TracebackType
+from typing import Iterable, Iterator, Iterable, List, Optional, Type
+
+from .._backends.sync import SyncBackend
+from .._backends.base import SOCKET_OPTION, NetworkBackend
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Request, Response
+from .._synchronization import Event, ShieldCancellation, ThreadLock
+from .connection import HTTPConnection
+from .interfaces import ConnectionInterface, RequestInterface
+
+
+class PoolRequest:
+    def __init__(self, request: Request) -> None:
+        self.request = request
+        self.connection: Optional[ConnectionInterface] = None
+        self._connection_acquired = Event()
+
+    def assign_to_connection(
+        self, connection: Optional[ConnectionInterface]
     ) -> None:
-        """
-        A wrapper around the response stream that we return from
-        `.handle_request()`.
-
-        Ensures that when `stream.close()` is called, the connection pool
-        is notified via a callback.
-        """
-        self.stream = stream
         self.connection = connection
-        self.callback = callback
+        self._connection_acquired.set()
 
-    def __iter__(self) -> Iterator[bytes]:
-        for chunk in self.stream:
-            yield chunk
+    def clear_connection(self) -> None:
+        self.connection = None
+        self._connection_acquired = Event()
 
-    def close(self) -> None:
-        try:
-            # Call the underlying stream close callback.
-            # This will be a call to `SyncHTTP11Connection._response_closed()`
-            # or `SyncHTTP2Stream._response_closed()`.
-            self.stream.close()
-        finally:
-            # Call the connection pool close callback.
-            # This will be a call to `SyncConnectionPool._response_closed()`.
-            self.callback(self.connection)
+    def wait_for_connection(
+        self, timeout: Optional[float] = None
+    ) -> ConnectionInterface:
+        if self.connection is None:
+            self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
+
+    def is_queued(self) -> bool:
+        return self.connection is None
 
 
-class SyncConnectionPool(SyncHTTPTransport):
+class ConnectionPool(RequestInterface):
     """
     A connection pool for making HTTP requests.
-
-    Parameters
-    ----------
-    ssl_context:
-        An SSL context to use for verifying connections.
-    max_connections:
-        The maximum number of concurrent connections to allow.
-    max_keepalive_connections:
-        The maximum number of connections to allow before closing keep-alive
-        connections.
-    keepalive_expiry:
-        The maximum time to allow before closing a keep-alive connection.
-    http1:
-        Enable/Disable HTTP/1.1 support. Defaults to True.
-    http2:
-        Enable/Disable HTTP/2 support. Defaults to False.
-    uds:
-        Path to a Unix Domain Socket to use instead of TCP sockets.
-    local_address:
-        Local address to connect from. Can also be used to connect using a particular
-        address family. Using ``local_address="0.0.0.0"`` will connect using an
-        ``AF_INET`` address (IPv4), while using ``local_address="::"`` will connect
-        using an ``AF_INET6`` address (IPv6).
-    retries:
-        The maximum number of retries when trying to establish a connection.
-    backend:
-        A name indicating which concurrency backend to use.
     """
 
     def __init__(
         self,
-        ssl_context: SSLContext = None,
-        max_connections: int = None,
-        max_keepalive_connections: int = None,
-        keepalive_expiry: float = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
         http1: bool = True,
         http2: bool = False,
-        uds: str = None,
-        local_address: str = None,
         retries: int = 0,
-        max_keepalive: int = None,
-        backend: Union[SyncBackend, str] = "sync",
-    ):
-        if max_keepalive is not None:
-            warnings.warn(
-                "'max_keepalive' is deprecated. Use 'max_keepalive_connections'.",
-                DeprecationWarning,
-            )
-            max_keepalive_connections = max_keepalive
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+            socket_options: Socket options that have to be included
+             in the TCP socket when the connection was established.
+        """
+        self._ssl_context = ssl_context
 
-        if isinstance(backend, str):
-            backend = lookup_sync_backend(backend)
+        self._max_connections = (
+            sys.maxsize if max_connections is None else max_connections
+        )
+        self._max_keepalive_connections = (
+            sys.maxsize
+            if max_keepalive_connections is None
+            else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(
+            self._max_connections, self._max_keepalive_connections
+        )
 
-        self._ssl_context = SSLContext() if ssl_context is None else ssl_context
-        self._max_connections = max_connections
-        self._max_keepalive_connections = max_keepalive_connections
         self._keepalive_expiry = keepalive_expiry
         self._http1 = http1
         self._http2 = http2
-        self._uds = uds
-        self._local_address = local_address
         self._retries = retries
-        self._connections: Dict[Origin, Set[SyncHTTPConnection]] = {}
-        self._thread_lock = ThreadLock()
-        self._backend = backend
-        self._next_keepalive_check = 0.0
-
-        if not (http1 or http2):
-            raise ValueError("Either http1 or http2 must be True.")
-
-        if http2:
-            try:
-                import h2  # noqa: F401
-            except ImportError:
-                raise ImportError(
-                    "Attempted to use http2=True, but the 'h2' "
-                    "package is not installed. Use 'pip install httpcore[http2]'."
-                )
+        self._local_address = local_address
+        self._uds = uds
 
-    @property
-    def _connection_semaphore(self) -> SyncSemaphore:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_internal_semaphore"):
-            if self._max_connections is not None:
-                self._internal_semaphore = self._backend.create_semaphore(
-                    self._max_connections, exc_class=PoolTimeout
-                )
-            else:
-                self._internal_semaphore = NullSemaphore()
-
-        return self._internal_semaphore
+        self._network_backend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+        self._socket_options = socket_options
 
-    @property
-    def _connection_acquiry_lock(self) -> SyncLock:
-        if not hasattr(self, "_internal_connection_acquiry_lock"):
-            self._internal_connection_acquiry_lock = self._backend.create_lock()
-        return self._internal_connection_acquiry_lock
+        # The mutable state on a connection pool is the queue of incoming requests,
+        # and the set of connections that are servicing those requests.
+        self._connections: List[ConnectionInterface] = []
+        self._requests: List[PoolRequest] = []
 
-    def _create_connection(
-        self,
-        origin: Tuple[bytes, bytes, int],
-    ) -> SyncHTTPConnection:
-        return SyncHTTPConnection(
+        # We only mutate the state of the connection pool within an 'optional_thread_lock'
+        # context. This holds a threading lock unless we're running in async mode,
+        # in which case it is a no-op.
+        self._optional_thread_lock = ThreadLock()
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        return HTTPConnection(
             origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
             http1=self._http1,
             http2=self._http2,
-            keepalive_expiry=self._keepalive_expiry,
-            uds=self._uds,
-            ssl_context=self._ssl_context,
-            local_address=self._local_address,
             retries=self._retries,
-            backend=self._backend,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+            socket_options=self._socket_options,
         )
 
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        if not url[0]:
+    @property
+    def connections(self) -> List[ConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <HTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._connections)
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
             raise UnsupportedProtocol(
-                "Request URL missing either an 'http://' or 'https://' protocol."
+                "Request URL is missing an 'http://' or 'https://' protocol."
             )
-
-        if url[0] not in (b"http", b"https"):
-            protocol = url[0].decode("ascii")
+        if scheme not in ("http", "https", "ws", "wss"):
             raise UnsupportedProtocol(
-                f"Request URL has an unsupported protocol '{protocol}://'."
+                f"Request URL has an unsupported protocol '{scheme}://'."
             )
 
-        if not url[1]:
-            raise LocalProtocolError("Missing hostname in URL.")
-
-        origin = url_to_origin(url)
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        self._keepalive_sweep()
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
 
-        connection: Optional[SyncHTTPConnection] = None
-        while connection is None:
-            with self._connection_acquiry_lock:
-                # We get-or-create a connection as an atomic operation, to ensure
-                # that HTTP/2 requests issued in close concurrency will end up
-                # on the same connection.
-                logger.trace("get_connection_from_pool=%r", origin)
-                connection = self._get_connection_from_pool(origin)
+        with self._optional_thread_lock:
+            # Add the incoming request to our request queue.
+            pool_request = PoolRequest(request)
+            self._requests.append(pool_request)
 
-                if connection is None:
-                    connection = self._create_connection(origin=origin)
-                    logger.trace("created connection=%r", connection)
-                    self._add_to_pool(connection, timeout=timeout)
+        try:
+            while True:
+                with self._optional_thread_lock:
+                    # Assign incoming requests to available connections,
+                    # closing or creating new connections as required.
+                    closing = self._assign_requests_to_connections()
+                self._close_connections(closing)
+
+                # Wait until this request has an assigned connection.
+                connection = pool_request.wait_for_connection(timeout=timeout)
+
+                try:
+                    # Send the request on the assigned connection.
+                    response = connection.handle_request(
+                        pool_request.request
+                    )
+                except ConnectionNotAvailable:
+                    # In some cases a connection may initially be available to
+                    # handle a request, but then become unavailable.
+                    #
+                    # In this case we clear the connection and try again.
+                    pool_request.clear_connection()
                 else:
-                    logger.trace("reuse connection=%r", connection)
-
-            try:
-                response = connection.handle_request(
-                    method, url, headers=headers, stream=stream, extensions=extensions
-                )
-            except NewConnectionRequired:
-                connection = None
-            except BaseException:  # noqa: PIE786
-                # See https://github.com/encode/httpcore/pull/305 for motivation
-                # behind catching 'BaseException' rather than 'Exception' here.
-                logger.trace("remove from pool connection=%r", connection)
-                self._remove_from_pool(connection)
-                raise
-
-        status_code, headers, stream, extensions = response
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
+                    break  # pragma: nocover
+
+        except BaseException as exc:
+            with self._optional_thread_lock:
+                # For any exception or cancellation we remove the request from
+                # the queue, and then re-assign requests to connections.
+                self._requests.remove(pool_request)
+                closing = self._assign_requests_to_connections()
+
+            self._close_connections(closing)
+            raise exc from None
+
+        # Return the response. Note that in this case we still have to manage
+        # the point at which the response is closed.
+        assert isinstance(response.stream, Iterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=PoolByteStream(
+                stream=response.stream, pool_request=pool_request, pool=self
+            ),
+            extensions=response.extensions,
         )
-        return status_code, headers, wrapped_stream, extensions
-
-    def _get_connection_from_pool(self, origin: Origin) -> Optional[SyncHTTPConnection]:
-        # Determine expired keep alive connections on this origin.
-        reuse_connection = None
-        connections_to_close = set()
-
-        for connection in self._connections_for_origin(origin):
-            if connection.should_close():
-                connections_to_close.add(connection)
-                self._remove_from_pool(connection)
-            elif connection.is_available():
-                reuse_connection = connection
-
-        # Close any dropped connections.
-        for connection in connections_to_close:
-            connection.close()
-
-        return reuse_connection
-
-    def _response_closed(self, connection: SyncHTTPConnection) -> None:
-        remove_from_pool = False
-        close_connection = False
-
-        if connection.is_closed():
-            remove_from_pool = True
-        elif connection.is_idle():
-            num_connections = len(self._get_all_connections())
-            if (
-                self._max_keepalive_connections is not None
-                and num_connections > self._max_keepalive_connections
-            ):
-                remove_from_pool = True
-                close_connection = True
 
-        if remove_from_pool:
-            self._remove_from_pool(connection)
+    def _assign_requests_to_connections(self) -> List[ConnectionInterface]:
+        """
+        Manage the state of the connection pool, assigning incoming
+        requests to connections as available.
 
-        if close_connection:
-            connection.close()
+        Called whenever a new request is added or removed from the pool.
 
-    def _keepalive_sweep(self) -> None:
-        """
-        Remove any IDLE connections that have expired past their keep-alive time.
+        Any closing connections are returned, allowing the I/O for closing
+        those connections to be handled seperately.
         """
-        if self._keepalive_expiry is None:
-            return
+        closing_connections = []
+
+        # First we handle cleaning up any connections that are closed,
+        # have expired their keep-alive, or surplus idle connections.
+        for connection in list(self._connections):
+            if connection.is_closed():
+                # log: "removing closed connection"
+                self._connections.remove(connection)
+            elif connection.has_expired():
+                # log: "closing expired connection"
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+            elif (
+                connection.is_idle()
+                and len([connection.is_idle() for connection in self._connections])
+                > self._max_keepalive_connections
+            ):
+                # log: "closing idle connection"
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+
+        # Assign queued requests to connections.
+        queued_requests = [request for request in self._requests if request.is_queued()]
+        for pool_request in queued_requests:
+            origin = pool_request.request.url.origin
+            avilable_connections = [
+                connection
+                for connection in self._connections
+                if connection.can_handle_request(origin) and connection.is_available()
+            ]
+            idle_connections = [
+                connection for connection in self._connections if connection.is_idle()
+            ]
+
+            # There are three cases for how we may be able to handle the request:
+            #
+            # 1. There is an existing connection that can handle the request.
+            # 2. We can create a new connection to handle the request.
+            # 3. We can close an idle connection and then create a new connection
+            #    to handle the request.
+            if avilable_connections:
+                # log: "reusing existing connection"
+                connection = avilable_connections[0]
+                pool_request.assign_to_connection(connection)
+            elif len(self._connections) < self._max_connections:
+                # log: "creating new connection"
+                connection = self.create_connection(origin)
+                self._connections.append(connection)
+                pool_request.assign_to_connection(connection)
+            elif idle_connections:
+                # log: "closing idle connection"
+                connection = idle_connections[0]
+                self._connections.remove(connection)
+                closing_connections.append(connection)
+                # log: "creating new connection"
+                connection = self.create_connection(origin)
+                self._connections.append(connection)
+                pool_request.assign_to_connection(connection)
+
+        return closing_connections
+
+    def _close_connections(self, closing: List[ConnectionInterface]) -> None:
+        # Close connections which have been removed from the pool.
+        with ShieldCancellation():
+            for connection in closing:
+                connection.close()
+
+    def close(self) -> None:
+        # Explicitly close the connection pool.
+        # Clears all existing requests and connections.
+        with self._optional_thread_lock:
+            closing_connections = list(self._connections)
+            self._connections = []
+        self._close_connections(closing_connections)
 
-        now = self._backend.time()
-        if now < self._next_keepalive_check:
-            return
+    def __enter__(self) -> "ConnectionPool":
+        return self
 
-        self._next_keepalive_check = now + min(1.0, self._keepalive_expiry)
-        connections_to_close = set()
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        with self._optional_thread_lock:
+            request_is_queued = [request.is_queued() for request in self._requests]
+            connection_is_idle = [
+                connection.is_idle() for connection in self._connections
+            ]
+
+            num_active_requests = request_is_queued.count(False)
+            num_queued_requests = request_is_queued.count(True)
+            num_active_connections = connection_is_idle.count(False)
+            num_idle_connections = connection_is_idle.count(True)
+
+        requests_info = (
+            f"Requests: {num_active_requests} active, {num_queued_requests} queued"
+        )
+        connection_info = (
+            f"Connections: {num_active_connections} active, {num_idle_connections} idle"
+        )
 
-        for connection in self._get_all_connections():
-            if connection.should_close():
-                connections_to_close.add(connection)
-                self._remove_from_pool(connection)
+        return f"<{class_name} [{requests_info} | {connection_info}]>"
 
-        for connection in connections_to_close:
-            connection.close()
 
-    def _add_to_pool(
-        self, connection: SyncHTTPConnection, timeout: TimeoutDict
+class PoolByteStream:
+    def __init__(
+        self,
+        stream: Iterable[bytes],
+        pool_request: PoolRequest,
+        pool: ConnectionPool,
     ) -> None:
-        logger.trace("adding connection to pool=%r", connection)
-        self._connection_semaphore.acquire(timeout=timeout.get("pool", None))
-        with self._thread_lock:
-            self._connections.setdefault(connection.origin, set())
-            self._connections[connection.origin].add(connection)
-
-    def _remove_from_pool(self, connection: SyncHTTPConnection) -> None:
-        logger.trace("removing connection from pool=%r", connection)
-        with self._thread_lock:
-            if connection in self._connections.get(connection.origin, set()):
-                self._connection_semaphore.release()
-                self._connections[connection.origin].remove(connection)
-                if not self._connections[connection.origin]:
-                    del self._connections[connection.origin]
-
-    def _connections_for_origin(self, origin: Origin) -> Set[SyncHTTPConnection]:
-        return set(self._connections.get(origin, set()))
-
-    def _get_all_connections(self) -> Set[SyncHTTPConnection]:
-        connections: Set[SyncHTTPConnection] = set()
-        for connection_set in self._connections.values():
-            connections |= connection_set
-        return connections
+        self._stream = stream
+        self._pool_request = pool_request
+        self._pool = pool
+        self._closed = False
 
-    def close(self) -> None:
-        connections = self._get_all_connections()
-        for connection in connections:
-            self._remove_from_pool(connection)
+    def __iter__(self) -> Iterator[bytes]:
+        try:
+            for part in self._stream:
+                yield part
+        except BaseException as exc:
+            self.close()
+            raise exc from None
 
-        # Close all connections
-        for connection in connections:
-            connection.close()
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with ShieldCancellation():
+                if hasattr(self._stream, "close"):
+                    self._stream.close()
 
-    def get_connection_info(self) -> Dict[str, List[str]]:
-        """
-        Returns a dict of origin URLs to a list of summary strings for each connection.
-        """
-        self._keepalive_sweep()
+            with self._pool._optional_thread_lock:
+                self._pool._requests.remove(self._pool_request)
+                closing = self._pool._assign_requests_to_connections()
 
-        stats = {}
-        for origin, connections in self._connections.items():
-            stats[origin_to_url_string(origin)] = sorted(
-                [connection.info() for connection in connections]
-            )
-        return stats
+            self._pool._close_connections(closing)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http.py
deleted file mode 100644
index c128a96..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http.py
+++ /dev/null
@@ -1,42 +0,0 @@
-from ssl import SSLContext
-
-from .._backends.sync import SyncSocketStream
-from .._types import TimeoutDict
-from .base import SyncHTTPTransport
-
-
-class SyncBaseHTTPConnection(SyncHTTPTransport):
-    def info(self) -> str:
-        raise NotImplementedError()  # pragma: nocover
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        """
-        raise NotImplementedError()  # pragma: nocover
-
-    def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> SyncSocketStream:
-        """
-        Upgrade the underlying socket to TLS.
-        """
-        raise NotImplementedError()  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http11.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http11.py
index def42f2..a74ff8e 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http11.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http11.py
@@ -1,192 +1,196 @@
 import enum
+import logging
+import ssl
 import time
-from ssl import SSLContext
-from typing import Iterator, List, Optional, Tuple, Union, cast
+from types import TracebackType
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
 
 import h11
 
-from .._backends.sync import SyncSocketStream
-from .._bytestreams import IteratorByteStream
-from .._exceptions import LocalProtocolError, RemoteProtocolError, map_exceptions
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger
-from .base import SyncByteStream, NewConnectionRequired
-from .http import SyncBaseHTTPConnection
+from .._backends.base import NetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    WriteError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import Lock, ShieldCancellation
+from .._trace import Trace
+from .interfaces import ConnectionInterface
 
-H11Event = Union[
+logger = logging.getLogger("httpcore.http11")
+
+
+# A subset of `h11.Event` types supported by `_send_event`
+H11SendEvent = Union[
     h11.Request,
-    h11.Response,
-    h11.InformationalResponse,
     h11.Data,
     h11.EndOfMessage,
-    h11.ConnectionClosed,
 ]
 
 
-class ConnectionState(enum.IntEnum):
+class HTTPConnectionState(enum.IntEnum):
     NEW = 0
     ACTIVE = 1
     IDLE = 2
     CLOSED = 3
 
 
-logger = get_logger(__name__)
-
-
-class SyncHTTP11Connection(SyncBaseHTTPConnection):
+class HTTP11Connection(ConnectionInterface):
     READ_NUM_BYTES = 64 * 1024
+    MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024
 
-    def __init__(self, socket: SyncSocketStream, keepalive_expiry: float = None):
-        self.socket = socket
-
+    def __init__(
+        self,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: Optional[float] = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
         self._keepalive_expiry: Optional[float] = keepalive_expiry
-        self._should_expire_at: Optional[float] = None
-        self._h11_state = h11.Connection(our_role=h11.CLIENT)
-        self._state = ConnectionState.NEW
-
-    def __repr__(self) -> str:
-        return f"<SyncHTTP11Connection [{self._state.name}]>"
-
-    def _now(self) -> float:
-        return time.monotonic()
-
-    def _server_disconnected(self) -> bool:
-        """
-        Return True if the connection is idle, and the underlying socket is readable.
-        The only valid state the socket can be readable here is when the b""
-        EOF marker is about to be returned, indicating a server disconnect.
-        """
-        return self._state == ConnectionState.IDLE and self.socket.is_readable()
-
-    def _keepalive_expired(self) -> bool:
-        """
-        Return True if the connection is idle, and has passed it's keepalive
-        expiry time.
-        """
-        return (
-            self._state == ConnectionState.IDLE
-            and self._should_expire_at is not None
-            and self._now() >= self._should_expire_at
+        self._expire_at: Optional[float] = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = Lock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(
+            our_role=h11.CLIENT,
+            max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE,
         )
 
-    def info(self) -> str:
-        return f"HTTP/1.1, {self._state.name}"
-
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is in a state where it should be closed.
-        """
-        return self._server_disconnected() or self._keepalive_expired()
-
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        return self._state == ConnectionState.IDLE
-
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        return self._state == ConnectionState.CLOSED
-
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        """
-        return self._state == ConnectionState.IDLE
-
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        """
-        Send a single HTTP/1.1 request.
-
-        Note that there is no kind of task/thread locking at this layer of interface.
-        Dealing with locking for concurrency is handled by the `SyncHTTPConnection`.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        if self._state in (ConnectionState.NEW, ConnectionState.IDLE):
-            self._state = ConnectionState.ACTIVE
-            self._should_expire_at = None
-        else:
-            raise NewConnectionRequired()
-
-        self._send_request(method, url, headers, timeout)
-        self._send_request_body(stream, timeout)
-        (
-            http_version,
-            status_code,
-            reason_phrase,
-            headers,
-        ) = self._receive_response(timeout)
-        response_stream = IteratorByteStream(
-            iterator=self._receive_response_data(timeout),
-            close_func=self._response_closed,
-        )
-        extensions = {
-            "http_version": http_version,
-            "reason_phrase": reason_phrase,
-        }
-        return (status_code, headers, response_stream, extensions)
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
+
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            try:
+                with Trace(
+                    "send_request_headers", logger, request, kwargs
+                ) as trace:
+                    self._send_request_headers(**kwargs)
+                with Trace("send_request_body", logger, request, kwargs) as trace:
+                    self._send_request_body(**kwargs)
+            except WriteError:
+                # If we get a write error while we're writing the request,
+                # then we supress this error and move on to attempting to
+                # read the response. Servers can sometimes close the request
+                # pre-emptively and then respond with a well formed HTTP
+                # error response.
+                pass
+
+            with Trace(
+                "receive_response_headers", logger, request, kwargs
+            ) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                    trailing_data,
+                ) = self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            network_stream = self._network_stream
+
+            # CONNECT or Upgrade request
+            if (status == 101) or (
+                (request.method == b"CONNECT") and (200 <= status < 300)
+            ):
+                network_stream = HTTP11UpgradeStream(network_stream, trailing_data)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": network_stream,
+                },
+            )
+        except BaseException as exc:
+            with ShieldCancellation():
+                with Trace("response_closed", logger, request) as trace:
+                    self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
 
-    def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> SyncSocketStream:
-        timeout = {} if timeout is None else timeout
-        self.socket = self.socket.start_tls(hostname, ssl_context, timeout)
-        return self.socket
-
-    def _send_request(
-        self, method: bytes, url: URL, headers: Headers, timeout: TimeoutDict
-    ) -> None:
-        """
-        Send the request line and headers.
-        """
-        logger.trace("send_request method=%r url=%r headers=%s", method, url, headers)
-        _scheme, _host, _port, target = url
         with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
-            event = h11.Request(method=method, target=target, headers=headers)
-        self._send_event(event, timeout)
-
-    def _send_request_body(self, stream: SyncByteStream, timeout: TimeoutDict) -> None:
-        """
-        Send the request body.
-        """
-        # Send the request body.
-        for chunk in stream:
-            logger.trace("send_data=Data(<%d bytes>)", len(chunk))
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        self._send_event(event, timeout=timeout)
+
+    def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, Iterable)
+        for chunk in request.stream:
             event = h11.Data(data=chunk)
-            self._send_event(event, timeout)
+            self._send_event(event, timeout=timeout)
 
-        # Finalize sending the request.
-        event = h11.EndOfMessage()
-        self._send_event(event, timeout)
+        self._send_event(h11.EndOfMessage(), timeout=timeout)
 
-    def _send_event(self, event: H11Event, timeout: TimeoutDict) -> None:
-        """
-        Send a single `h11` event to the network, waiting for the data to
-        drain before returning.
-        """
+    def _send_event(
+        self, event: h11.Event, timeout: Optional[float] = None
+    ) -> None:
         bytes_to_send = self._h11_state.send(event)
-        self.socket.write(bytes_to_send, timeout)
-
-    def _receive_response(
-        self, timeout: TimeoutDict
-    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]]]:
-        """
-        Read the response status and headers from the network.
-        """
+        if bytes_to_send is not None:
+            self._network_stream.write(bytes_to_send, timeout=timeout)
+
+    # Receiving the response...
+
+    def _receive_response_headers(
+        self, request: Request
+    ) -> Tuple[bytes, int, bytes, List[Tuple[bytes, bytes]], bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
         while True:
-            event = self._receive_event(timeout)
+            event = self._receive_event(timeout=timeout)
             if isinstance(event, h11.Response):
                 break
+            if (
+                isinstance(event, h11.InformationalResponse)
+                and event.status_code == 101
+            ):
+                break
 
         http_version = b"HTTP/" + event.http_version
 
@@ -194,31 +198,32 @@ def _receive_response(
         # raw header casing, rather than the enforced lowercase headers.
         headers = event.headers.raw_items()
 
-        return http_version, event.status_code, event.reason, headers
+        trailing_data, _ = self._h11_state.trailing_data
+
+        return http_version, event.status_code, event.reason, headers, trailing_data
+
+    def _receive_response_body(self, request: Request) -> Iterator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
 
-    def _receive_response_data(self, timeout: TimeoutDict) -> Iterator[bytes]:
-        """
-        Read the response data from the network.
-        """
         while True:
-            event = self._receive_event(timeout)
+            event = self._receive_event(timeout=timeout)
             if isinstance(event, h11.Data):
-                logger.trace("receive_event=Data(<%d bytes>)", len(event.data))
                 yield bytes(event.data)
             elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
-                logger.trace("receive_event=%r", event)
                 break
 
-    def _receive_event(self, timeout: TimeoutDict) -> H11Event:
-        """
-        Read a single `h11` event, reading more data from the network if needed.
-        """
+    def _receive_event(
+        self, timeout: Optional[float] = None
+    ) -> Union[h11.Event, Type[h11.PAUSED]]:
         while True:
             with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
                 event = self._h11_state.next_event()
 
             if event is h11.NEED_DATA:
-                data = self.socket.read(self.READ_NUM_BYTES, timeout)
+                data = self._network_stream.read(
+                    self.READ_NUM_BYTES, timeout=timeout
+                )
 
                 # If we feed this case through h11 we'll raise an exception like:
                 #
@@ -226,40 +231,156 @@ def _receive_event(self, timeout: TimeoutDict) -> H11Event:
                 #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
                 #
                 # Which is accurate, but not very informative from an end-user
-                # perspective. Instead we handle messaging for this case distinctly.
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
                 if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
                     msg = "Server disconnected without sending a response."
                     raise RemoteProtocolError(msg)
 
                 self._h11_state.receive_data(data)
             else:
-                assert event is not h11.NEED_DATA
-                break
-        return event
+                # mypy fails to narrow the type in the above if statement above
+                return event  # type: ignore[return-value]
 
     def _response_closed(self) -> None:
-        logger.trace(
-            "response_closed our_state=%r their_state=%r",
-            self._h11_state.our_state,
-            self._h11_state.their_state,
+        with self._state_lock:
+            if (
+                self._h11_state.our_state is h11.DONE
+                and self._h11_state.their_state is h11.DONE
+            ):
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                self.close()
+
+    # Once the connection is no longer required...
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # The ConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        keepalive_expired = self._expire_at is not None and now > self._expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = (
+            self._state == HTTPConnectionState.IDLE
+            and self._network_stream.get_extra_info("is_readable")
         )
-        if (
-            self._h11_state.our_state is h11.DONE
-            and self._h11_state.their_state is h11.DONE
-        ):
-            self._h11_state.start_next_cycle()
-            self._state = ConnectionState.IDLE
-            if self._keepalive_expiry is not None:
-                self._should_expire_at = self._now() + self._keepalive_expiry
-        else:
-            self.close()
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/1.1, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTP11Connection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: HTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    def __iter__(self) -> Iterator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            with Trace("receive_response_body", logger, self._request, kwargs):
+                for chunk in self._connection._receive_response_body(**kwargs):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with ShieldCancellation():
+                self.close()
+            raise exc
 
     def close(self) -> None:
-        if self._state != ConnectionState.CLOSED:
-            self._state = ConnectionState.CLOSED
+        if not self._closed:
+            self._closed = True
+            with Trace("response_closed", logger, self._request):
+                self._connection._response_closed()
+
+
+class HTTP11UpgradeStream(NetworkStream):
+    def __init__(self, stream: NetworkStream, leading_data: bytes) -> None:
+        self._stream = stream
+        self._leading_data = leading_data
+
+    def read(self, max_bytes: int, timeout: Optional[float] = None) -> bytes:
+        if self._leading_data:
+            buffer = self._leading_data[:max_bytes]
+            self._leading_data = self._leading_data[max_bytes:]
+            return buffer
+        else:
+            return self._stream.read(max_bytes, timeout)
 
-            if self._h11_state.our_state is h11.MUST_CLOSE:
-                event = h11.ConnectionClosed()
-                self._h11_state.send(event)
+    def write(self, buffer: bytes, timeout: Optional[float] = None) -> None:
+        self._stream.write(buffer, timeout)
 
-            self.socket.close()
+    def close(self) -> None:
+        self._stream.close()
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> NetworkStream:
+        return self._stream.start_tls(ssl_context, server_hostname, timeout)
+
+    def get_extra_info(self, info: str) -> Any:
+        return self._stream.get_extra_info(info)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http2.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http2.py
index 72436ae..d141d45 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http2.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http2.py
@@ -1,173 +1,190 @@
 import enum
+import logging
 import time
-from ssl import SSLContext
-from typing import Iterator, Dict, List, Optional, Tuple, cast
+import types
+import typing
 
+import h2.config
 import h2.connection
 import h2.events
-from h2.config import H2Configuration
-from h2.exceptions import NoAvailableStreamIDError
-from h2.settings import SettingCodes, Settings
+import h2.exceptions
+import h2.settings
 
-from .._backends.sync import SyncBackend, SyncLock, SyncSemaphore, SyncSocketStream
-from .._bytestreams import IteratorByteStream
-from .._exceptions import LocalProtocolError, PoolTimeout, RemoteProtocolError
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger
-from .base import SyncByteStream, NewConnectionRequired
-from .http import SyncBaseHTTPConnection
+from .._backends.base import NetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import Lock, Semaphore, ShieldCancellation
+from .._trace import Trace
+from .interfaces import ConnectionInterface
 
-logger = get_logger(__name__)
+logger = logging.getLogger("httpcore.http2")
 
 
-class ConnectionState(enum.IntEnum):
-    IDLE = 0
+def has_body_headers(request: Request) -> bool:
+    return any(
+        k.lower() == b"content-length" or k.lower() == b"transfer-encoding"
+        for k, v in request.headers
+    )
+
+
+class HTTPConnectionState(enum.IntEnum):
     ACTIVE = 1
-    CLOSED = 2
+    IDLE = 2
+    CLOSED = 3
 
 
-class SyncHTTP2Connection(SyncBaseHTTPConnection):
+class HTTP2Connection(ConnectionInterface):
     READ_NUM_BYTES = 64 * 1024
-    CONFIG = H2Configuration(validate_inbound_headers=False)
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
 
     def __init__(
         self,
-        socket: SyncSocketStream,
-        backend: SyncBackend,
-        keepalive_expiry: float = None,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: typing.Optional[float] = None,
     ):
-        self.socket = socket
-
-        self._backend = backend
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: typing.Optional[float] = keepalive_expiry
         self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
-
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: typing.Optional[float] = None
+        self._request_count = 0
+        self._init_lock = Lock()
+        self._state_lock = Lock()
+        self._read_lock = Lock()
+        self._write_lock = Lock()
         self._sent_connection_init = False
-        self._streams: Dict[int, SyncHTTP2Stream] = {}
-        self._events: Dict[int, List[h2.events.Event]] = {}
-
-        self._keepalive_expiry: Optional[float] = keepalive_expiry
-        self._should_expire_at: Optional[float] = None
-        self._state = ConnectionState.ACTIVE
-        self._exhausted_available_stream_ids = False
-
-    def __repr__(self) -> str:
-        return f"<SyncHTTP2Connection [{self._state}]>"
-
-    def info(self) -> str:
-        return f"HTTP/2, {self._state.name}, {len(self._streams)} streams"
-
-    def _now(self) -> float:
-        return time.monotonic()
+        self._used_all_stream_ids = False
+        self._connection_error = False
+
+        # Mapping from stream ID to response stream events.
+        self._events: typing.Dict[
+            int,
+            typing.Union[
+                h2.events.ResponseReceived,
+                h2.events.DataReceived,
+                h2.events.StreamEnded,
+                h2.events.StreamReset,
+            ],
+        ] = {}
+
+        # Connection terminated events are stored as state since
+        # we need to handle them for all streams.
+        self._connection_terminated: typing.Optional[
+            h2.events.ConnectionTerminated
+        ] = None
+
+        self._read_exception: typing.Optional[Exception] = None
+        self._write_exception: typing.Optional[Exception] = None
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(
+                f"Attempted to send request to {request.url.origin} on connection "
+                f"to {self._origin}"
+            )
 
-    def should_close(self) -> bool:
-        """
-        Return `True` if the connection is currently idle, and the keepalive
-        timeout has passed.
-        """
-        return (
-            self._state == ConnectionState.IDLE
-            and self._should_expire_at is not None
-            and self._now() >= self._should_expire_at
-        )
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
 
-    def is_idle(self) -> bool:
-        """
-        Return `True` if the connection is currently idle.
-        """
-        return self._state == ConnectionState.IDLE
+        with self._init_lock:
+            if not self._sent_connection_init:
+                try:
+                    kwargs = {"request": request}
+                    with Trace("send_connection_init", logger, request, kwargs):
+                        self._send_connection_init(**kwargs)
+                except BaseException as exc:
+                    with ShieldCancellation():
+                        self.close()
+                    raise exc
 
-    def is_closed(self) -> bool:
-        """
-        Return `True` if the connection has been closed.
-        """
-        return self._state == ConnectionState.CLOSED
+                self._sent_connection_init = True
 
-    def is_available(self) -> bool:
-        """
-        Return `True` if the connection is currently able to accept an outgoing request.
-        This occurs when any of the following occur:
-
-        * The connection has not yet been opened, and HTTP/2 support is enabled.
-          We don't *know* at this point if we'll end up on an HTTP/2 connection or
-          not, but we *might* do, so we indicate availability.
-        * The connection has been opened, and is currently idle.
-        * The connection is open, and is an HTTP/2 connection. The connection must
-          also not have exhausted the maximum total number of stream IDs.
-        """
-        return (
-            self._state != ConnectionState.CLOSED
-            and not self._exhausted_available_stream_ids
-        )
+                # Initially start with just 1 until the remote server provides
+                # its max_concurrent_streams value
+                self._max_streams = 1
 
-    @property
-    def init_lock(self) -> SyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_initialization_lock"):
-            self._initialization_lock = self._backend.create_lock()
-        return self._initialization_lock
-
-    @property
-    def read_lock(self) -> SyncLock:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_read_lock"):
-            self._read_lock = self._backend.create_lock()
-        return self._read_lock
-
-    @property
-    def max_streams_semaphore(self) -> SyncSemaphore:
-        # We do this lazily, to make sure backend autodetection always
-        # runs within an async context.
-        if not hasattr(self, "_max_streams_semaphore"):
-            max_streams = self._h2_state.local_settings.max_concurrent_streams
-            self._max_streams_semaphore = self._backend.create_semaphore(
-                max_streams, exc_class=PoolTimeout
-            )
-        return self._max_streams_semaphore
+                local_settings_max_streams = (
+                    self._h2_state.local_settings.max_concurrent_streams
+                )
+                self._max_streams_semaphore = Semaphore(local_settings_max_streams)
 
-    def start_tls(
-        self, hostname: bytes, ssl_context: SSLContext, timeout: TimeoutDict = None
-    ) -> SyncSocketStream:
-        raise NotImplementedError("TLS upgrade not supported on HTTP/2 connections.")
+                for _ in range(local_settings_max_streams - self._max_streams):
+                    self._max_streams_semaphore.acquire()
 
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        with self.init_lock:
-            if not self._sent_connection_init:
-                # The very first stream is responsible for initiating the connection.
-                self._state = ConnectionState.ACTIVE
-                self.send_connection_init(timeout)
-                self._sent_connection_init = True
+        self._max_streams_semaphore.acquire()
 
-        self.max_streams_semaphore.acquire()
         try:
-            try:
-                stream_id = self._h2_state.get_next_available_stream_id()
-            except NoAvailableStreamIDError:
-                self._exhausted_available_stream_ids = True
-                raise NewConnectionRequired()
-            else:
-                self._state = ConnectionState.ACTIVE
-                self._should_expire_at = None
-
-            h2_stream = SyncHTTP2Stream(stream_id=stream_id, connection=self)
-            self._streams[stream_id] = h2_stream
+            stream_id = self._h2_state.get_next_available_stream_id()
             self._events[stream_id] = []
-            return h2_stream.handle_request(method, url, headers, stream, extensions)
-        except Exception:  # noqa: PIE786
-            self.max_streams_semaphore.release()
-            raise
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: nocover
+            self._used_all_stream_ids = True
+            self._request_count -= 1
+            raise ConnectionNotAvailable()
 
-    def send_connection_init(self, timeout: TimeoutDict) -> None:
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            with Trace("send_request_headers", logger, request, kwargs):
+                self._send_request_headers(request=request, stream_id=stream_id)
+            with Trace("send_request_body", logger, request, kwargs):
+                self._send_request_body(request=request, stream_id=stream_id)
+            with Trace(
+                "receive_response_headers", logger, request, kwargs
+            ) as trace:
+                status, headers = self._receive_response(
+                    request=request, stream_id=stream_id
+                )
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={
+                    "http_version": b"HTTP/2",
+                    "network_stream": self._network_stream,
+                    "stream_id": stream_id,
+                },
+            )
+        except BaseException as exc:  # noqa: PIE786
+            with ShieldCancellation():
+                kwargs = {"stream_id": stream_id}
+                with Trace("response_closed", logger, request, kwargs):
+                    self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_terminated:  # pragma: nocover
+                    raise RemoteProtocolError(self._connection_terminated)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: nocover
+
+            raise exc
+
+    def _send_connection_init(self, request: Request) -> None:
         """
         The HTTP/2 connection requires some initial setup before we can start
         using individual request/response streams on it.
@@ -175,15 +192,15 @@ def send_connection_init(self, timeout: TimeoutDict) -> None:
         # Need to set these manually here instead of manipulating via
         # __setitem__() otherwise the H2Connection will emit SettingsUpdate
         # frames in addition to sending the undesired defaults.
-        self._h2_state.local_settings = Settings(
+        self._h2_state.local_settings = h2.settings.Settings(
             client=True,
             initial_values={
                 # Disable PUSH_PROMISE frames from the server since we don't do anything
                 # with them for now.  Maybe when we support caching?
-                SettingCodes.ENABLE_PUSH: 0,
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
                 # These two are taken from h2 for safe defaults
-                SettingCodes.MAX_CONCURRENT_STREAMS: 100,
-                SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
             },
         )
 
@@ -194,223 +211,85 @@ def send_connection_init(self, timeout: TimeoutDict) -> None:
             h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL
         ]
 
-        logger.trace("initiate_connection=%r", self)
         self._h2_state.initiate_connection()
-        self._h2_state.increment_flow_control_window(2 ** 24)
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def is_socket_readable(self) -> bool:
-        return self.socket.is_readable()
-
-    def close(self) -> None:
-        logger.trace("close_connection=%r", self)
-        if self._state != ConnectionState.CLOSED:
-            self._state = ConnectionState.CLOSED
-
-            self.socket.close()
-
-    def wait_for_outgoing_flow(self, stream_id: int, timeout: TimeoutDict) -> int:
-        """
-        Returns the maximum allowable outgoing flow for a given stream.
-        If the allowable flow is zero, then waits on the network until
-        WindowUpdated frames have increased the flow rate.
-        https://tools.ietf.org/html/rfc7540#section-6.9
-        """
-        local_flow = self._h2_state.local_flow_control_window(stream_id)
-        connection_flow = self._h2_state.max_outbound_frame_size
-        flow = min(local_flow, connection_flow)
-        while flow == 0:
-            self.receive_events(timeout)
-            local_flow = self._h2_state.local_flow_control_window(stream_id)
-            connection_flow = self._h2_state.max_outbound_frame_size
-            flow = min(local_flow, connection_flow)
-        return flow
+        self._h2_state.increment_flow_control_window(2**24)
+        self._write_outgoing_data(request)
 
-    def wait_for_event(self, stream_id: int, timeout: TimeoutDict) -> h2.events.Event:
-        """
-        Returns the next event for a given stream.
-        If no events are available yet, then waits on the network until
-        an event is available.
-        """
-        with self.read_lock:
-            while not self._events[stream_id]:
-                self.receive_events(timeout)
-        return self._events[stream_id].pop(0)
+    # Sending the request...
 
-    def receive_events(self, timeout: TimeoutDict) -> None:
+    def _send_request_headers(self, request: Request, stream_id: int) -> None:
         """
-        Read some data from the network, and update the H2 state.
+        Send the request headers to a given stream ID.
         """
-        data = self.socket.read(self.READ_NUM_BYTES, timeout)
-        if data == b"":
-            raise RemoteProtocolError("Server disconnected")
-
-        events = self._h2_state.receive_data(data)
-        for event in events:
-            event_stream_id = getattr(event, "stream_id", 0)
-            logger.trace("receive_event stream_id=%r event=%s", event_stream_id, event)
-
-            if hasattr(event, "error_code"):
-                raise RemoteProtocolError(event)
-
-            if event_stream_id in self._events:
-                self._events[event_stream_id].append(event)
-
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def send_headers(
-        self, stream_id: int, headers: Headers, end_stream: bool, timeout: TimeoutDict
-    ) -> None:
-        logger.trace("send_headers stream_id=%r headers=%r", stream_id, headers)
-        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
-        self._h2_state.increment_flow_control_window(2 ** 24, stream_id=stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def send_data(self, stream_id: int, chunk: bytes, timeout: TimeoutDict) -> None:
-        logger.trace("send_data stream_id=%r chunk=%r", stream_id, chunk)
-        self._h2_state.send_data(stream_id, chunk)
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def end_stream(self, stream_id: int, timeout: TimeoutDict) -> None:
-        logger.trace("end_stream stream_id=%r", stream_id)
-        self._h2_state.end_stream(stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def acknowledge_received_data(
-        self, stream_id: int, amount: int, timeout: TimeoutDict
-    ) -> None:
-        self._h2_state.acknowledge_received_data(amount, stream_id)
-        data_to_send = self._h2_state.data_to_send()
-        self.socket.write(data_to_send, timeout)
-
-    def close_stream(self, stream_id: int) -> None:
-        try:
-            logger.trace("close_stream stream_id=%r", stream_id)
-            del self._streams[stream_id]
-            del self._events[stream_id]
-
-            if not self._streams:
-                if self._state == ConnectionState.ACTIVE:
-                    if self._exhausted_available_stream_ids:
-                        self.close()
-                    else:
-                        self._state = ConnectionState.IDLE
-                        if self._keepalive_expiry is not None:
-                            self._should_expire_at = (
-                                self._now() + self._keepalive_expiry
-                            )
-        finally:
-            self.max_streams_semaphore.release()
-
-
-class SyncHTTP2Stream:
-    def __init__(self, stream_id: int, connection: SyncHTTP2Connection) -> None:
-        self.stream_id = stream_id
-        self.connection = connection
-
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        headers = [(k.lower(), v) for (k, v) in headers]
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-
-        # Send the request.
-        seen_headers = set(key for key, value in headers)
-        has_body = (
-            b"content-length" in seen_headers or b"transfer-encoding" in seen_headers
-        )
-
-        self.send_headers(method, url, headers, has_body, timeout)
-        if has_body:
-            self.send_body(stream, timeout)
-
-        # Receive the response.
-        status_code, headers = self.receive_response(timeout)
-        response_stream = IteratorByteStream(
-            iterator=self.body_iter(timeout), close_func=self._response_closed
-        )
-
-        extensions = {
-            "http_version": b"HTTP/2",
-        }
-        return (status_code, headers, response_stream, extensions)
-
-    def send_headers(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        has_body: bool,
-        timeout: TimeoutDict,
-    ) -> None:
-        scheme, hostname, port, path = url
+        end_stream = not has_body_headers(request)
 
         # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
         # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
         # HTTP/1.1 style headers, and map them appropriately if we end up on
         # an HTTP/2 connection.
-        authority = None
-
-        for k, v in headers:
-            if k == b"host":
-                authority = v
-                break
-
-        if authority is None:
-            # Mirror the same error we'd see with `h11`, so that the behaviour
-            # is consistent. Although we're dealing with an `:authority`
-            # pseudo-header by this point, from an end-user perspective the issue
-            # is that the outgoing request needed to include a `host` header.
-            raise LocalProtocolError("Missing mandatory Host: header")
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
 
         headers = [
-            (b":method", method),
+            (b":method", request.method),
             (b":authority", authority),
-            (b":scheme", scheme),
-            (b":path", path),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
         ] + [
-            (k, v)
-            for k, v in headers
-            if k
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
             not in (
                 b"host",
                 b"transfer-encoding",
             )
         ]
-        end_stream = not has_body
 
-        self.connection.send_headers(self.stream_id, headers, end_stream, timeout)
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        self._write_outgoing_data(request)
+
+    def _send_request_body(self, request: Request, stream_id: int) -> None:
+        """
+        Iterate over the request body sending it to a given stream ID.
+        """
+        if not has_body_headers(request):
+            return
 
-    def send_body(self, stream: SyncByteStream, timeout: TimeoutDict) -> None:
-        for data in stream:
-            while data:
-                max_flow = self.connection.wait_for_outgoing_flow(
-                    self.stream_id, timeout
-                )
-                chunk_size = min(len(data), max_flow)
-                chunk, data = data[:chunk_size], data[chunk_size:]
-                self.connection.send_data(self.stream_id, chunk, timeout)
+        assert isinstance(request.stream, typing.Iterable)
+        for data in request.stream:
+            self._send_stream_data(request, stream_id, data)
+        self._send_end_stream(request, stream_id)
+
+    def _send_stream_data(
+        self, request: Request, stream_id: int, data: bytes
+    ) -> None:
+        """
+        Send a single chunk of data in one or more data frames.
+        """
+        while data:
+            max_flow = self._wait_for_outgoing_flow(request, stream_id)
+            chunk_size = min(len(data), max_flow)
+            chunk, data = data[:chunk_size], data[chunk_size:]
+            self._h2_state.send_data(stream_id, chunk)
+            self._write_outgoing_data(request)
+
+    def _send_end_stream(self, request: Request, stream_id: int) -> None:
+        """
+        Send an empty data frame on on a given stream ID with the END_STREAM flag set.
+        """
+        self._h2_state.end_stream(stream_id)
+        self._write_outgoing_data(request)
 
-        self.connection.end_stream(self.stream_id, timeout)
+    # Receiving the response...
 
-    def receive_response(
-        self, timeout: TimeoutDict
-    ) -> Tuple[int, List[Tuple[bytes, bytes]]]:
+    def _receive_response(
+        self, request: Request, stream_id: int
+    ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]]]:
         """
-        Read the response status and headers from the network.
+        Return the response status code and headers for a given stream ID.
         """
         while True:
-            event = self.connection.wait_for_event(self.stream_id, timeout)
+            event = self._receive_stream_event(request, stream_id)
             if isinstance(event, h2.events.ResponseReceived):
                 break
 
@@ -424,17 +303,287 @@ def receive_response(
 
         return (status_code, headers)
 
-    def body_iter(self, timeout: TimeoutDict) -> Iterator[bytes]:
+    def _receive_response_body(
+        self, request: Request, stream_id: int
+    ) -> typing.Iterator[bytes]:
+        """
+        Iterator that returns the bytes of the response body for a given stream ID.
+        """
         while True:
-            event = self.connection.wait_for_event(self.stream_id, timeout)
+            event = self._receive_stream_event(request, stream_id)
             if isinstance(event, h2.events.DataReceived):
                 amount = event.flow_controlled_length
-                self.connection.acknowledge_received_data(
-                    self.stream_id, amount, timeout
-                )
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                self._write_outgoing_data(request)
                 yield event.data
-            elif isinstance(event, (h2.events.StreamEnded, h2.events.StreamReset)):
+            elif isinstance(event, h2.events.StreamEnded):
                 break
 
-    def _response_closed(self) -> None:
-        self.connection.close_stream(self.stream_id)
+    def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> typing.Union[
+        h2.events.ResponseReceived, h2.events.DataReceived, h2.events.StreamEnded
+    ]:
+        """
+        Return the next available event for a given stream ID.
+
+        Will read more data from the network if required.
+        """
+        while not self._events.get(stream_id):
+            self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        if isinstance(event, h2.events.StreamReset):
+            raise RemoteProtocolError(event)
+        return event
+
+    def _receive_events(
+        self, request: Request, stream_id: typing.Optional[int] = None
+    ) -> None:
+        """
+        Read some data from the network until we see one or more events
+        for a given stream ID.
+        """
+        with self._read_lock:
+            if self._connection_terminated is not None:
+                last_stream_id = self._connection_terminated.last_stream_id
+                if stream_id and last_stream_id and stream_id > last_stream_id:
+                    self._request_count -= 1
+                    raise ConnectionNotAvailable()
+                raise RemoteProtocolError(self._connection_terminated)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = self._read_incoming_data(request)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        with Trace(
+                            "receive_remote_settings", logger, request
+                        ) as trace:
+                            self._receive_remote_settings_change(event)
+                            trace.return_value = event
+
+                    elif isinstance(
+                        event,
+                        (
+                            h2.events.ResponseReceived,
+                            h2.events.DataReceived,
+                            h2.events.StreamEnded,
+                            h2.events.StreamReset,
+                        ),
+                    ):
+                        if event.stream_id in self._events:
+                            self._events[event.stream_id].append(event)
+
+                    elif isinstance(event, h2.events.ConnectionTerminated):
+                        self._connection_terminated = event
+
+        self._write_outgoing_data(request)
+
+    def _receive_remote_settings_change(self, event: h2.events.Event) -> None:
+        max_concurrent_streams = event.changed_settings.get(
+            h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS
+        )
+        if max_concurrent_streams:
+            new_max_streams = min(
+                max_concurrent_streams.new_value,
+                self._h2_state.local_settings.max_concurrent_streams,
+            )
+            if new_max_streams and new_max_streams != self._max_streams:
+                while new_max_streams > self._max_streams:
+                    self._max_streams_semaphore.release()
+                    self._max_streams += 1
+                while new_max_streams < self._max_streams:
+                    self._max_streams_semaphore.acquire()
+                    self._max_streams -= 1
+
+    def _response_closed(self, stream_id: int) -> None:
+        self._max_streams_semaphore.release()
+        del self._events[stream_id]
+        with self._state_lock:
+            if self._connection_terminated and not self._events:
+                self.close()
+
+            elif self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: nocover
+                    self.close()
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # Wrappers around network read/write operations...
+
+    def _read_incoming_data(
+        self, request: Request
+    ) -> typing.List[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: nocover
+
+        try:
+            data = self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        events: typing.List[h2.events.Event] = self._h2_state.receive_data(data)
+
+        return events
+
+    def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: nocover
+
+            try:
+                self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: nocover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow: int = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size: int = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow == 0:
+            self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+            and not (
+                self._h2_state.state_machine.state
+                == h2.connection.ConnectionState.CLOSED
+            )
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        return self._expire_at is not None and now > self._expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return (
+            f"{origin!r}, HTTP/2, {self._state.name}, "
+            f"Request Count: {self._request_count}"
+        )
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return (
+            f"<{class_name} [{origin!r}, {self._state.name}, "
+            f"Request Count: {self._request_count}]>"
+        )
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> "HTTP2Connection":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: typing.Optional[typing.Type[BaseException]] = None,
+        exc_value: typing.Optional[BaseException] = None,
+        traceback: typing.Optional[types.TracebackType] = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(
+        self, connection: HTTP2Connection, request: Request, stream_id: int
+    ) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            with Trace("receive_response_body", logger, self._request, kwargs):
+                for chunk in self._connection._receive_response_body(
+                    request=self._request, stream_id=self._stream_id
+                ):
+                    yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with ShieldCancellation():
+                self.close()
+            raise exc
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            with Trace("response_closed", logger, self._request, kwargs):
+                self._connection._response_closed(stream_id=self._stream_id)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http_proxy.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http_proxy.py
index c4ae9db..6acac9a 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http_proxy.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/http_proxy.py
@@ -1,35 +1,45 @@
-from http import HTTPStatus
-from ssl import SSLContext
-from typing import Tuple, cast
+import logging
+import ssl
+from base64 import b64encode
+from typing import Iterable, List, Mapping, Optional, Sequence, Tuple, Union
 
-from .._bytestreams import ByteStream
+from .._backends.base import SOCKET_OPTION, NetworkBackend
 from .._exceptions import ProxyError
-from .._types import URL, Headers, TimeoutDict
-from .._utils import get_logger, url_to_origin
-from .base import SyncByteStream
-from .connection import SyncHTTPConnection
-from .connection_pool import SyncConnectionPool, ResponseByteStream
-
-logger = get_logger(__name__)
-
-
-def get_reason_phrase(status_code: int) -> str:
-    try:
-        return HTTPStatus(status_code).phrase
-    except ValueError:
-        return ""
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+HeadersAsSequence = Sequence[Tuple[Union[bytes, str], Union[bytes, str]]]
+HeadersAsMapping = Mapping[Union[bytes, str], Union[bytes, str]]
+
+
+logger = logging.getLogger("httpcore.proxy")
 
 
 def merge_headers(
-    default_headers: Headers = None, override_headers: Headers = None
-) -> Headers:
+    default_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+    override_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+) -> List[Tuple[bytes, bytes]]:
     """
-    Append default_headers and override_headers, de-duplicating if a key existing in
-    both cases.
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
     """
-    default_headers = [] if default_headers is None else default_headers
-    override_headers = [] if override_headers is None else override_headers
-    has_override = set([key.lower() for key, value in override_headers])
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set(key.lower() for key, value in override_headers)
     default_headers = [
         (key, value)
         for key, value in default_headers
@@ -38,243 +48,321 @@ def merge_headers(
     return default_headers + override_headers
 
 
-class SyncHTTPProxy(SyncConnectionPool):
+def build_auth_header(username: bytes, password: bytes) -> bytes:
+    userpass = username + b":" + password
+    return b"Basic " + b64encode(userpass)
+
+
+class HTTPProxy(ConnectionPool):
     """
-    A connection pool for making HTTP requests via an HTTP proxy.
-
-    Parameters
-    ----------
-    proxy_url:
-        The URL of the proxy service as a 4-tuple of (scheme, host, port, path).
-    proxy_headers:
-        A list of proxy headers to include.
-    proxy_mode:
-        A proxy mode to operate in. May be "DEFAULT", "FORWARD_ONLY", or "TUNNEL_ONLY".
-    ssl_context:
-        An SSL context to use for verifying connections.
-    max_connections:
-        The maximum number of concurrent connections to allow.
-    max_keepalive_connections:
-        The maximum number of connections to allow before closing keep-alive
-        connections.
-    http2:
-        Enable HTTP/2 support.
+    A connection pool that sends requests via an HTTP proxy.
     """
 
     def __init__(
         self,
-        proxy_url: URL,
-        proxy_headers: Headers = None,
-        proxy_mode: str = "DEFAULT",
-        ssl_context: SSLContext = None,
-        max_connections: int = None,
-        max_keepalive_connections: int = None,
-        keepalive_expiry: float = None,
+        proxy_url: Union[URL, bytes, str],
+        proxy_auth: Optional[Tuple[Union[bytes, str], Union[bytes, str]]] = None,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+        max_connections: Optional[int] = 10,
+        max_keepalive_connections: Optional[int] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
         http2: bool = False,
-        backend: str = "sync",
-        # Deprecated argument style:
-        max_keepalive: int = None,
-    ):
-        assert proxy_mode in ("DEFAULT", "FORWARD_ONLY", "TUNNEL_ONLY")
-
-        self.proxy_origin = url_to_origin(proxy_url)
-        self.proxy_headers = [] if proxy_headers is None else proxy_headers
-        self.proxy_mode = proxy_mode
+        retries: int = 0,
+        local_address: Optional[str] = None,
+        uds: Optional[str] = None,
+        network_backend: Optional[NetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
         super().__init__(
             ssl_context=ssl_context,
             max_connections=max_connections,
             max_keepalive_connections=max_keepalive_connections,
             keepalive_expiry=keepalive_expiry,
+            http1=http1,
             http2=http2,
-            backend=backend,
-            max_keepalive=max_keepalive,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+            socket_options=socket_options,
         )
 
-    def handle_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        if self._keepalive_expiry is not None:
-            self._keepalive_sweep()
-
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
         if (
-            self.proxy_mode == "DEFAULT" and url[0] == b"http"
-        ) or self.proxy_mode == "FORWARD_ONLY":
-            # By default HTTP requests should be forwarded.
-            logger.trace(
-                "forward_request proxy_origin=%r proxy_headers=%r method=%r url=%r",
-                self.proxy_origin,
-                self.proxy_headers,
-                method,
-                url,
-            )
-            return self._forward_request(
-                method, url, headers=headers, stream=stream, extensions=extensions
-            )
-        else:
-            # By default HTTPS should be tunnelled.
-            logger.trace(
-                "tunnel_request proxy_origin=%r proxy_headers=%r method=%r url=%r",
-                self.proxy_origin,
-                self.proxy_headers,
-                method,
-                url,
-            )
-            return self._tunnel_request(
-                method, url, headers=headers, stream=stream, extensions=extensions
+            self._proxy_url.scheme == b"http" and proxy_ssl_context is not None
+        ):  # pragma: no cover
+            raise RuntimeError(
+                "The `proxy_ssl_context` argument is not allowed for the http scheme"
             )
 
-    def _forward_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        """
-        Forwarded proxy requests include the entire URL as the HTTP target,
-        rather than just the path.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-        origin = self.proxy_origin
-        connection = self._get_connection_from_pool(origin)
-
-        if connection is None:
-            connection = SyncHTTPConnection(
-                origin=origin,
-                http2=self._http2,
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            authorization = build_auth_header(username, password)
+            self._proxy_headers = [
+                (b"Proxy-Authorization", authorization)
+            ] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        if origin.scheme == b"http":
+            return ForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                remote_origin=origin,
                 keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
+                network_backend=self._network_backend,
+                proxy_ssl_context=self._proxy_ssl_context,
             )
-            self._add_to_pool(connection, timeout)
+        return TunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            proxy_ssl_context=self._proxy_ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
 
-        # Issue a forwarded proxy request...
 
-        # GET https://www.example.org/path HTTP/1.1
-        # [proxy headers]
-        # [headers]
-        scheme, host, port, path = url
-        if port is None:
-            target = b"%b://%b%b" % (scheme, host, path)
-        else:
-            target = b"%b://%b:%d%b" % (scheme, host, port, path)
+class ForwardHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_headers: Union[HeadersAsMapping, HeadersAsSequence, None] = None,
+        keepalive_expiry: Optional[float] = None,
+        network_backend: Optional[NetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+    ) -> None:
+        self._connection = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._remote_origin = remote_origin
+
+    def handle_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url),
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        return self._connection.handle_request(proxy_request)
 
-        url = self.proxy_origin + (target,)
-        headers = merge_headers(self.proxy_headers, headers)
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
 
-        (status_code, headers, stream, extensions,) = connection.handle_request(
-            method, url, headers=headers, stream=stream, extensions=extensions
-        )
+    def close(self) -> None:
+        self._connection.close()
 
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
-        )
+    def info(self) -> str:
+        return self._connection.info()
 
-        return status_code, headers, wrapped_stream, extensions
+    def is_available(self) -> bool:
+        return self._connection.is_available()
 
-    def _tunnel_request(
-        self,
-        method: bytes,
-        url: URL,
-        headers: Headers,
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> Tuple[int, Headers, SyncByteStream, dict]:
-        """
-        Tunnelled proxy requests require an initial CONNECT request to
-        establish the connection, and then send regular requests.
-        """
-        timeout = cast(TimeoutDict, extensions.get("timeout", {}))
-        origin = url_to_origin(url)
-        connection = self._get_connection_from_pool(origin)
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
 
-        if connection is None:
-            scheme, host, port = origin
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
 
-            # First, create a connection to the proxy server
-            proxy_connection = SyncHTTPConnection(
-                origin=self.proxy_origin,
-                http2=self._http2,
-                keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
-            )
 
-            # Issue a CONNECT request...
-
-            # CONNECT www.example.org:80 HTTP/1.1
-            # [proxy-headers]
-            target = b"%b:%d" % (host, port)
-            connect_url = self.proxy_origin + (target,)
-            connect_headers = [(b"Host", target), (b"Accept", b"*/*")]
-            connect_headers = merge_headers(connect_headers, self.proxy_headers)
-
-            try:
-                (
-                    proxy_status_code,
-                    _,
-                    proxy_stream,
-                    _,
-                ) = proxy_connection.handle_request(
-                    b"CONNECT",
-                    connect_url,
+class TunnelHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_ssl_context: Optional[ssl.SSLContext] = None,
+        proxy_headers: Optional[Sequence[Tuple[bytes, bytes]]] = None,
+        keepalive_expiry: Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: Optional[NetworkBackend] = None,
+        socket_options: Optional[Iterable[SOCKET_OPTION]] = None,
+    ) -> None:
+        self._connection: ConnectionInterface = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = Lock()
+        self._connected = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers(
+                    [(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers
+                )
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
                     headers=connect_headers,
-                    stream=ByteStream(b""),
-                    extensions=extensions,
+                    extensions=request.extensions,
                 )
-
-                proxy_reason = get_reason_phrase(proxy_status_code)
-                logger.trace(
-                    "tunnel_response proxy_status_code=%r proxy_reason=%r ",
-                    proxy_status_code,
-                    proxy_reason,
+                connect_response = self._connection.handle_request(
+                    connect_request
                 )
-                # Read the response data without closing the socket
-                for _ in proxy_stream:
-                    pass
 
-                # See if the tunnel was successfully established.
-                if proxy_status_code < 200 or proxy_status_code > 299:
-                    msg = "%d %s" % (proxy_status_code, proxy_reason)
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = "%d %s" % (connect_response.status, reason_str)
+                    self._connection.close()
                     raise ProxyError(msg)
 
-                # Upgrade to TLS if required
-                # We assume the target speaks TLS on the specified port
-                if scheme == b"https":
-                    proxy_connection.start_tls(host, self._ssl_context, timeout)
-            except Exception as exc:
-                proxy_connection.close()
-                raise ProxyError(exc)
-
-            # The CONNECT request is successful, so we have now SWITCHED PROTOCOLS.
-            # This means the proxy connection is now unusable, and we must create
-            # a new one for regular requests, making sure to use the same socket to
-            # retain the tunnel.
-            connection = SyncHTTPConnection(
-                origin=origin,
-                http2=self._http2,
-                keepalive_expiry=self._keepalive_expiry,
-                ssl_context=self._ssl_context,
-                socket=proxy_connection.socket,
-            )
-            self._add_to_pool(connection, timeout)
+                stream = connect_response.extensions["network_stream"]
 
-        # Once the connection has been established we can send requests on
-        # it as normal.
-        (status_code, headers, stream, extensions,) = connection.handle_request(
-            method,
-            url,
-            headers=headers,
-            stream=stream,
-            extensions=extensions,
-        )
+                # Upgrade the stream to SSL
+                ssl_context = (
+                    default_ssl_context()
+                    if self._ssl_context is None
+                    else self._ssl_context
+                )
+                alpn_protocols = ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": self._remote_origin.host.decode("ascii"),
+                    "timeout": timeout,
+                }
+                with Trace("start_tls", logger, request, kwargs) as trace:
+                    stream = stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = (
+                    ssl_object is not None
+                    and ssl_object.selected_alpn_protocol() == "h2"
+                )
 
-        wrapped_stream = ResponseByteStream(
-            stream, connection=connection, callback=self._response_closed
-        )
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import HTTP2Connection
+
+                    self._connection = HTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = HTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
 
-        return status_code, headers, wrapped_stream, extensions
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/interfaces.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/interfaces.py
new file mode 100644
index 0000000..5e95be1
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/interfaces.py
@@ -0,0 +1,135 @@
+from contextlib import contextmanager
+from typing import Iterator, Optional, Union
+
+from .._models import (
+    URL,
+    Extensions,
+    HeaderTypes,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class RequestInterface:
+    def request(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, Iterator[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            response.read()
+        finally:
+            response.close()
+        return response
+
+    @contextmanager
+    def stream(
+        self,
+        method: Union[bytes, str],
+        url: Union[URL, bytes, str],
+        *,
+        headers: HeaderTypes = None,
+        content: Union[bytes, Iterator[bytes], None] = None,
+        extensions: Optional[Extensions] = None,
+    ) -> Iterator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            yield response
+        finally:
+            response.close()
+
+    def handle_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: nocover
+
+
+class ConnectionInterface(RequestInterface):
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: nocover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: nocover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: nocover
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: nocover
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_sync/socks_proxy.py b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/socks_proxy.py
new file mode 100644
index 0000000..502e4d7
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_sync/socks_proxy.py
@@ -0,0 +1,342 @@
+import logging
+import ssl
+import typing
+
+from socksio import socks5
+
+from .._backends.sync import SyncBackend
+from .._backends.base import NetworkBackend, NetworkStream
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+logger = logging.getLogger("httpcore.socks")
+
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+def _init_socks5_connection(
+    stream: NetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+) -> None:
+    conn = socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes)
+
+    # Auth method response
+    incoming_bytes = stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(
+            f"Requested {requested} from proxy server, but got {responded}."
+        )
+
+    if response.method == socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        stream.write(outgoing_bytes)
+
+        # Username/password response
+        incoming_bytes = stream.read(max_bytes=4096)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(
+        socks5.SOCKS5CommandRequest.from_address(
+            socks5.SOCKS5Command.CONNECT, (host, port)
+        )
+    )
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes)
+
+    # Connect response
+    incoming_bytes = stream.read(max_bytes=4096)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socks5.SOCKS5Reply)
+    if response.reply_code != socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class SOCKSProxy(ConnectionPool):
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: typing.Union[URL, bytes, str],
+        proxy_auth: typing.Optional[
+            typing.Tuple[typing.Union[bytes, str], typing.Union[bytes, str]]
+        ] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        max_connections: typing.Optional[int] = 10,
+        max_keepalive_connections: typing.Optional[int] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        network_backend: typing.Optional[NetworkBackend] = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        return Socks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class Socks5Connection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: typing.Optional[typing.Tuple[bytes, bytes]] = None,
+        ssl_context: typing.Optional[ssl.SSLContext] = None,
+        keepalive_expiry: typing.Optional[float] = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: typing.Optional[NetworkBackend] = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: NetworkBackend = (
+            SyncBackend() if network_backend is None else network_backend
+        )
+        self._connect_lock = Lock()
+        self._connection: typing.Optional[ConnectionInterface] = None
+        self._connect_failed = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                    }
+                    with Trace(
+                        "setup_socks5_connection", logger, request, kwargs
+                    ) as trace:
+                        _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme == b"https":
+                        ssl_context = (
+                            default_ssl_context()
+                            if self._ssl_context is None
+                            else self._ssl_context
+                        )
+                        alpn_protocols = (
+                            ["http/1.1", "h2"] if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": sni_hostname
+                            or self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        with Trace("start_tls", logger, request, kwargs) as trace:
+                            stream = stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = (
+                        ssl_object is not None
+                        and ssl_object.selected_alpn_protocol() == "h2"
+                    )
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (
+                        self._http2 and not self._http1
+                    ):  # pragma: nocover
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: nocover
+                raise ConnectionNotAvailable()
+
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        if self._connection is not None:
+            self._connection.close()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2
+                and (self._remote_origin.scheme == b"https" or not self._http1)
+                and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: nocover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: nocover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_synchronization.py b/addon/globalPlugins/spellcheck/libs/httpcore/_synchronization.py
new file mode 100644
index 0000000..9619a39
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_synchronization.py
@@ -0,0 +1,317 @@
+import threading
+from types import TracebackType
+from typing import Optional, Type
+
+from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions
+
+# Our async synchronization primatives use either 'anyio' or 'trio' depending
+# on if they're running under asyncio or trio.
+
+try:
+    import trio
+except ImportError:  # pragma: nocover
+    trio = None  # type: ignore
+
+try:
+    import anyio
+except ImportError:  # pragma: nocover
+    anyio = None  # type: ignore
+
+
+def current_async_library() -> str:
+    # Determine if we're running under trio or asyncio.
+    # See https://sniffio.readthedocs.io/en/latest/
+    try:
+        import sniffio
+    except ImportError:  # pragma: nocover
+        environment = "asyncio"
+    else:
+        environment = sniffio.current_async_library()
+
+    if environment not in ("asyncio", "trio"):  # pragma: nocover
+        raise RuntimeError("Running under an unsupported async environment.")
+
+    if environment == "asyncio" and anyio is None:  # pragma: nocover
+        raise RuntimeError(
+            "Running with asyncio requires installation of 'httpcore[asyncio]'."
+        )
+
+    if environment == "trio" and trio is None:  # pragma: nocover
+        raise RuntimeError(
+            "Running with trio requires installation of 'httpcore[trio]'."
+        )
+
+    return environment
+
+
+class AsyncLock:
+    """
+    This is a standard lock.
+
+    In the sync case `Lock` provides thread locking.
+    In the async case `AsyncLock` provides async locking.
+    """
+
+    def __init__(self) -> None:
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a lock with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_lock = trio.Lock()
+        elif self._backend == "asyncio":
+            self._anyio_lock = anyio.Lock()
+
+    async def __aenter__(self) -> "AsyncLock":
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            await self._trio_lock.acquire()
+        elif self._backend == "asyncio":
+            await self._anyio_lock.acquire()
+
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self._backend == "trio":
+            self._trio_lock.release()
+        elif self._backend == "asyncio":
+            self._anyio_lock.release()
+
+
+class AsyncThreadLock:
+    """
+    This is a threading-only lock for no-I/O contexts.
+
+    In the sync case `ThreadLock` provides thread locking.
+    In the async case `AsyncThreadLock` is a no-op.
+    """
+
+    def __enter__(self) -> "AsyncThreadLock":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        pass
+
+
+class AsyncEvent:
+    def __init__(self) -> None:
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a lock with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_event = trio.Event()
+        elif self._backend == "asyncio":
+            self._anyio_event = anyio.Event()
+
+    def set(self) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            self._trio_event.set()
+        elif self._backend == "asyncio":
+            self._anyio_event.set()
+
+    async def wait(self, timeout: Optional[float] = None) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            trio_exc_map: ExceptionMapping = {trio.TooSlowError: PoolTimeout}
+            timeout_or_inf = float("inf") if timeout is None else timeout
+            with map_exceptions(trio_exc_map):
+                with trio.fail_after(timeout_or_inf):
+                    await self._trio_event.wait()
+        elif self._backend == "asyncio":
+            anyio_exc_map: ExceptionMapping = {TimeoutError: PoolTimeout}
+            with map_exceptions(anyio_exc_map):
+                with anyio.fail_after(timeout):
+                    await self._anyio_event.wait()
+
+
+class AsyncSemaphore:
+    def __init__(self, bound: int) -> None:
+        self._bound = bound
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a semaphore with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_semaphore = trio.Semaphore(
+                initial_value=self._bound, max_value=self._bound
+            )
+        elif self._backend == "asyncio":
+            self._anyio_semaphore = anyio.Semaphore(
+                initial_value=self._bound, max_value=self._bound
+            )
+
+    async def acquire(self) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            await self._trio_semaphore.acquire()
+        elif self._backend == "asyncio":
+            await self._anyio_semaphore.acquire()
+
+    async def release(self) -> None:
+        if self._backend == "trio":
+            self._trio_semaphore.release()
+        elif self._backend == "asyncio":
+            self._anyio_semaphore.release()
+
+
+class AsyncShieldCancellation:
+    # For certain portions of our codebase where we're dealing with
+    # closing connections during exception handling we want to shield
+    # the operation from being cancelled.
+    #
+    # with AsyncShieldCancellation():
+    #     ... # clean-up operations, shielded from cancellation.
+
+    def __init__(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a shielded scope with the correct implementation.
+        """
+        self._backend = current_async_library()
+
+        if self._backend == "trio":
+            self._trio_shield = trio.CancelScope(shield=True)
+        elif self._backend == "asyncio":
+            self._anyio_shield = anyio.CancelScope(shield=True)
+
+    def __enter__(self) -> "AsyncShieldCancellation":
+        if self._backend == "trio":
+            self._trio_shield.__enter__()
+        elif self._backend == "asyncio":
+            self._anyio_shield.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self._backend == "trio":
+            self._trio_shield.__exit__(exc_type, exc_value, traceback)
+        elif self._backend == "asyncio":
+            self._anyio_shield.__exit__(exc_type, exc_value, traceback)
+
+
+# Our thread-based synchronization primitives...
+
+
+class Lock:
+    """
+    This is a standard lock.
+
+    In the sync case `Lock` provides thread locking.
+    In the async case `AsyncLock` provides async locking.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> "Lock":
+        self._lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self._lock.release()
+
+
+class ThreadLock:
+    """
+    This is a threading-only lock for no-I/O contexts.
+
+    In the sync case `ThreadLock` provides thread locking.
+    In the async case `AsyncThreadLock` is a no-op.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> "ThreadLock":
+        self._lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        self._lock.release()
+
+
+class Event:
+    def __init__(self) -> None:
+        self._event = threading.Event()
+
+    def set(self) -> None:
+        self._event.set()
+
+    def wait(self, timeout: Optional[float] = None) -> None:
+        if timeout == float("inf"):  # pragma: no cover
+            timeout = None
+        if not self._event.wait(timeout=timeout):
+            raise PoolTimeout()  # pragma: nocover
+
+
+class Semaphore:
+    def __init__(self, bound: int) -> None:
+        self._semaphore = threading.Semaphore(value=bound)
+
+    def acquire(self) -> None:
+        self._semaphore.acquire()
+
+    def release(self) -> None:
+        self._semaphore.release()
+
+
+class ShieldCancellation:
+    # Thread-synchronous codebases don't support cancellation semantics.
+    # We have this class because we need to mirror the async and sync
+    # cases within our package, but it's just a no-op.
+    def __enter__(self) -> "ShieldCancellation":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_threadlock.py b/addon/globalPlugins/spellcheck/libs/httpcore/_threadlock.py
deleted file mode 100644
index 2ff2bc3..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_threadlock.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import threading
-from types import TracebackType
-from typing import Type
-
-
-class ThreadLock:
-    """
-    Provides thread safety when used as a sync context manager, or a
-    no-op when used as an async context manager.
-    """
-
-    def __init__(self) -> None:
-        self.lock = threading.Lock()
-
-    def __enter__(self) -> None:
-        self.lock.acquire()
-
-    def __exit__(
-        self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        self.lock.release()
-
-    async def __aenter__(self) -> None:
-        pass
-
-    async def __aexit__(
-        self,
-        exc_type: Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
-    ) -> None:
-        pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_trace.py b/addon/globalPlugins/spellcheck/libs/httpcore/_trace.py
new file mode 100644
index 0000000..b122a53
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_trace.py
@@ -0,0 +1,105 @@
+import inspect
+import logging
+from types import TracebackType
+from typing import Any, Dict, Optional, Type
+
+from ._models import Request
+
+
+class Trace:
+    def __init__(
+        self,
+        name: str,
+        logger: logging.Logger,
+        request: Optional[Request] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.name = name
+        self.logger = logger
+        self.trace_extension = (
+            None if request is None else request.extensions.get("trace")
+        )
+        self.debug = self.logger.isEnabledFor(logging.DEBUG)
+        self.kwargs = kwargs or {}
+        self.return_value: Any = None
+        self.should_trace = self.debug or self.trace_extension is not None
+        self.prefix = self.logger.name.split(".")[-1]
+
+    def trace(self, name: str, info: Dict[str, Any]) -> None:
+        if self.trace_extension is not None:
+            prefix_and_name = f"{self.prefix}.{name}"
+            ret = self.trace_extension(prefix_and_name, info)
+            if inspect.iscoroutine(ret):  # pragma: no cover
+                raise TypeError(
+                    "If you are using a synchronous interface, "
+                    "the callback of the `trace` extension should "
+                    "be a normal function instead of an asynchronous function."
+                )
+
+        if self.debug:
+            if not info or "return_value" in info and info["return_value"] is None:
+                message = name
+            else:
+                args = " ".join([f"{key}={value!r}" for key, value in info.items()])
+                message = f"{name} {args}"
+            self.logger.debug(message)
+
+    def __enter__(self) -> "Trace":
+        if self.should_trace:
+            info = self.kwargs
+            self.trace(f"{self.name}.started", info)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self.should_trace:
+            if exc_value is None:
+                info = {"return_value": self.return_value}
+                self.trace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                self.trace(f"{self.name}.failed", info)
+
+    async def atrace(self, name: str, info: Dict[str, Any]) -> None:
+        if self.trace_extension is not None:
+            prefix_and_name = f"{self.prefix}.{name}"
+            coro = self.trace_extension(prefix_and_name, info)
+            if not inspect.iscoroutine(coro):  # pragma: no cover
+                raise TypeError(
+                    "If you're using an asynchronous interface, "
+                    "the callback of the `trace` extension should "
+                    "be an asynchronous function rather than a normal function."
+                )
+            await coro
+
+        if self.debug:
+            if not info or "return_value" in info and info["return_value"] is None:
+                message = name
+            else:
+                args = " ".join([f"{key}={value!r}" for key, value in info.items()])
+                message = f"{name} {args}"
+            self.logger.debug(message)
+
+    async def __aenter__(self) -> "Trace":
+        if self.should_trace:
+            info = self.kwargs
+            await self.atrace(f"{self.name}.started", info)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        if self.should_trace:
+            if exc_value is None:
+                info = {"return_value": self.return_value}
+                await self.atrace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                await self.atrace(f"{self.name}.failed", info)
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_types.py b/addon/globalPlugins/spellcheck/libs/httpcore/_types.py
deleted file mode 100644
index 2f9eeba..0000000
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_types.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""
-Type definitions for type checking purposes.
-"""
-
-from typing import List, Mapping, Optional, Tuple, TypeVar, Union
-
-T = TypeVar("T")
-StrOrBytes = Union[str, bytes]
-Origin = Tuple[bytes, bytes, int]
-URL = Tuple[bytes, bytes, Optional[int], bytes]
-Headers = List[Tuple[bytes, bytes]]
-TimeoutDict = Mapping[str, Optional[float]]
diff --git a/addon/globalPlugins/spellcheck/libs/httpcore/_utils.py b/addon/globalPlugins/spellcheck/libs/httpcore/_utils.py
index 978b87a..df5dea8 100644
--- a/addon/globalPlugins/spellcheck/libs/httpcore/_utils.py
+++ b/addon/globalPlugins/spellcheck/libs/httpcore/_utils.py
@@ -1,83 +1,12 @@
-import itertools
-import logging
-import os
 import select
 import socket
 import sys
 import typing
 
-from ._types import URL, Origin
-
-_LOGGER_INITIALIZED = False
-TRACE_LOG_LEVEL = 5
-DEFAULT_PORTS = {b"http": 80, b"https": 443}
-
-
-class Logger(logging.Logger):
-    # Stub for type checkers.
-    def trace(self, message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
-        ...  # pragma: nocover
-
-
-def get_logger(name: str) -> Logger:
-    """
-    Get a `logging.Logger` instance, and optionally
-    set up debug logging based on the HTTPCORE_LOG_LEVEL or HTTPX_LOG_LEVEL
-    environment variables.
-    """
-    global _LOGGER_INITIALIZED
-    if not _LOGGER_INITIALIZED:
-        _LOGGER_INITIALIZED = True
-        logging.addLevelName(TRACE_LOG_LEVEL, "TRACE")
-
-        log_level = os.environ.get(
-            "HTTPCORE_LOG_LEVEL", os.environ.get("HTTPX_LOG_LEVEL", "")
-        ).upper()
-        if log_level in ("DEBUG", "TRACE"):
-            logger = logging.getLogger("httpcore")
-            logger.setLevel(logging.DEBUG if log_level == "DEBUG" else TRACE_LOG_LEVEL)
-            handler = logging.StreamHandler(sys.stderr)
-            handler.setFormatter(
-                logging.Formatter(
-                    fmt="%(levelname)s [%(asctime)s] %(name)s - %(message)s",
-                    datefmt="%Y-%m-%d %H:%M:%S",
-                )
-            )
-            logger.addHandler(handler)
-
-    logger = logging.getLogger(name)
-
-    def trace(message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
-        logger.log(TRACE_LOG_LEVEL, message, *args, **kwargs)
-
-    logger.trace = trace  # type: ignore
-
-    return typing.cast(Logger, logger)
-
-
-def url_to_origin(url: URL) -> Origin:
-    scheme, host, explicit_port = url[:3]
-    default_port = DEFAULT_PORTS[scheme]
-    port = default_port if explicit_port is None else explicit_port
-    return scheme, host, port
-
-
-def origin_to_url_string(origin: Origin) -> str:
-    scheme, host, explicit_port = origin
-    port = f":{explicit_port}" if explicit_port != DEFAULT_PORTS[scheme] else ""
-    return f"{scheme.decode('ascii')}://{host.decode('ascii')}{port}"
-
-
-def exponential_backoff(factor: float) -> typing.Iterator[float]:
-    yield 0
-    for n in itertools.count(2):
-        yield factor * (2 ** (n - 2))
-
 
 def is_socket_readable(sock: typing.Optional[socket.socket]) -> bool:
     """
     Return whether a socket, as identifed by its file descriptor, is readable.
-
     "A socket is readable" means that the read buffer isn't empty, i.e. that calling
     .recv() on it would immediately return some data.
     """
@@ -88,7 +17,7 @@ def is_socket_readable(sock: typing.Optional[socket.socket]) -> bool:
     # descriptor, we treat it as being readable, as if it the next read operation
     # on it is ready to return the terminating `b""`.
     sock_fd = None if sock is None else sock.fileno()
-    if sock_fd is None or sock_fd < 0:
+    if sock_fd is None or sock_fd < 0:  # pragma: nocover
         return True
 
     # The implementation below was stolen from:
@@ -97,7 +26,9 @@ def is_socket_readable(sock: typing.Optional[socket.socket]) -> bool:
 
     # Use select.select on Windows, and when poll is unavailable and select.poll
     # everywhere else. (E.g. When eventlet is in use. See #327)
-    if sys.platform == "win32" or getattr(select, "poll", None) is None:
+    if (
+        sys.platform == "win32" or getattr(select, "poll", None) is None
+    ):  # pragma: nocover
         rready, _, _ = select.select([sock_fd], [], [], 0)
         return bool(rready)
     p = select.poll()
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/__init__.py b/addon/globalPlugins/spellcheck/libs/httpx/__init__.py
index 4af3904..f61112f 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/__init__.py
@@ -1,6 +1,6 @@
 from .__version__ import __description__, __title__, __version__
 from ._api import delete, get, head, options, patch, post, put, request, stream
-from ._auth import Auth, BasicAuth, DigestAuth
+from ._auth import Auth, BasicAuth, DigestAuth, NetRCAuth
 from ._client import USE_CLIENT_DEFAULT, AsyncClient, Client
 from ._config import Limits, Proxy, Timeout, create_ssl_context
 from ._content import ByteStream
@@ -34,18 +34,30 @@
     WriteError,
     WriteTimeout,
 )
-from ._models import URL, Cookies, Headers, QueryParams, Request, Response
+from ._models import Cookies, Headers, Request, Response
 from ._status_codes import codes
 from ._transports.asgi import ASGITransport
-from ._transports.base import (
-    AsyncBaseTransport,
-    AsyncByteStream,
-    BaseTransport,
-    SyncByteStream,
-)
+from ._transports.base import AsyncBaseTransport, BaseTransport
 from ._transports.default import AsyncHTTPTransport, HTTPTransport
 from ._transports.mock import MockTransport
 from ._transports.wsgi import WSGITransport
+from ._types import AsyncByteStream, SyncByteStream
+from ._urls import URL, QueryParams
+
+try:
+    from ._main import main
+except ImportError:  # pragma: no cover
+
+    def main() -> None:  # type: ignore
+        import sys
+
+        print(
+            "The httpx command line client could not run because the required "
+            "dependencies were not installed.\nMake sure you've installed "
+            "everything with: pip install 'httpx[cli]'"
+        )
+        sys.exit(1)
+
 
 __all__ = [
     "__description__",
@@ -80,7 +92,9 @@
     "InvalidURL",
     "Limits",
     "LocalProtocolError",
+    "main",
     "MockTransport",
+    "NetRCAuth",
     "NetworkError",
     "options",
     "patch",
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/__version__.py b/addon/globalPlugins/spellcheck/libs/httpx/__version__.py
index bab8a1c..c121a89 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/__version__.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/__version__.py
@@ -1,3 +1,3 @@
 __title__ = "httpx"
 __description__ = "A next generation HTTP client, for Python 3."
-__version__ = "0.19.0"
+__version__ = "0.27.0"
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_api.py b/addon/globalPlugins/spellcheck/libs/httpx/_api.py
index da81853..b5821cc 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_api.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_api.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import typing
 from contextlib import contextmanager
 
@@ -10,6 +12,7 @@
     CookieTypes,
     HeaderTypes,
     ProxiesTypes,
+    ProxyTypes,
     QueryParamTypes,
     RequestContent,
     RequestData,
@@ -24,19 +27,20 @@ def request(
     method: str,
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: typing.Any = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    allow_redirects: bool = True,
+    follow_redirects: bool = False,
     verify: VerifyTypes = True,
-    cert: CertTypes = None,
+    cert: CertTypes | None = None,
     trust_env: bool = True,
 ) -> Response:
     """
@@ -63,10 +67,11 @@ def request(
     request.
     * **auth** - *(optional)* An authentication class to use when sending the
     request.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
     * **proxies** - *(optional)* A dictionary mapping proxy keys to proxy URLs.
     * **timeout** - *(optional)* The timeout configuration to use when sending
     the request.
-    * **allow_redirects** - *(optional)* Enables or disables HTTP redirects.
+    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
     * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to
     verify the identity of requested hosts. Either `True` (default CA bundle),
     a path to an SSL certificate file, an `ssl.SSLContext`, or `False`
@@ -91,6 +96,7 @@ def request(
     """
     with Client(
         cookies=cookies,
+        proxy=proxy,
         proxies=proxies,
         cert=cert,
         verify=verify,
@@ -107,7 +113,7 @@ def request(
             params=params,
             headers=headers,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
         )
 
 
@@ -116,19 +122,20 @@ def stream(
     method: str,
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: typing.Any = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    allow_redirects: bool = True,
+    follow_redirects: bool = False,
     verify: VerifyTypes = True,
-    cert: CertTypes = None,
+    cert: CertTypes | None = None,
     trust_env: bool = True,
 ) -> typing.Iterator[Response]:
     """
@@ -143,6 +150,7 @@ def stream(
     """
     with Client(
         cookies=cookies,
+        proxy=proxy,
         proxies=proxies,
         cert=cert,
         verify=verify,
@@ -159,7 +167,7 @@ def stream(
             params=params,
             headers=headers,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
         ) as response:
             yield response
 
@@ -167,13 +175,14 @@ def stream(
 def get(
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -183,8 +192,8 @@ def get(
 
     **Parameters**: See `httpx.request`.
 
-    Note that the `data`, `files`, and `json` parameters are not available on
-    this function, as `GET` requests should not include a request body.
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `GET` requests should not include a request body.
     """
     return request(
         "GET",
@@ -193,8 +202,9 @@ def get(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -205,13 +215,14 @@ def get(
 def options(
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -221,8 +232,8 @@ def options(
 
     **Parameters**: See `httpx.request`.
 
-    Note that the `data`, `files`, and `json` parameters are not available on
-    this function, as `OPTIONS` requests should not include a request body.
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `OPTIONS` requests should not include a request body.
     """
     return request(
         "OPTIONS",
@@ -231,8 +242,9 @@ def options(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -243,13 +255,14 @@ def options(
 def head(
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -259,8 +272,8 @@ def head(
 
     **Parameters**: See `httpx.request`.
 
-    Note that the `data`, `files`, and `json` parameters are not available on
-    this function, as `HEAD` requests should not include a request body.
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `HEAD` requests should not include a request body.
     """
     return request(
         "HEAD",
@@ -269,8 +282,9 @@ def head(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -281,17 +295,18 @@ def head(
 def post(
     url: URLTypes,
     *,
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: typing.Any = None,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -312,8 +327,9 @@ def post(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -324,17 +340,18 @@ def post(
 def put(
     url: URLTypes,
     *,
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: typing.Any = None,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -355,8 +372,9 @@ def put(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -367,17 +385,18 @@ def put(
 def patch(
     url: URLTypes,
     *,
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: typing.Any = None,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -398,8 +417,9 @@ def patch(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
@@ -410,13 +430,14 @@ def patch(
 def delete(
     url: URLTypes,
     *,
-    params: QueryParamTypes = None,
-    headers: HeaderTypes = None,
-    cookies: CookieTypes = None,
-    auth: AuthTypes = None,
-    proxies: ProxiesTypes = None,
-    allow_redirects: bool = True,
-    cert: CertTypes = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    proxies: ProxiesTypes | None = None,
+    follow_redirects: bool = False,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
     trust_env: bool = True,
@@ -426,8 +447,8 @@ def delete(
 
     **Parameters**: See `httpx.request`.
 
-    Note that the `data`, `files`, and `json` parameters are not available on
-    this function, as `DELETE` requests should not include a request body.
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `DELETE` requests should not include a request body.
     """
     return request(
         "DELETE",
@@ -436,8 +457,9 @@ def delete(
         headers=headers,
         cookies=cookies,
         auth=auth,
+        proxy=proxy,
         proxies=proxies,
-        allow_redirects=allow_redirects,
+        follow_redirects=follow_redirects,
         cert=cert,
         verify=verify,
         timeout=timeout,
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_auth.py b/addon/globalPlugins/spellcheck/libs/httpx/_auth.py
index 343f9cd..903e399 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_auth.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_auth.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import hashlib
 import os
 import re
@@ -7,9 +9,12 @@
 from urllib.request import parse_http_list
 
 from ._exceptions import ProtocolError
-from ._models import Request, Response
+from ._models import Cookies, Request, Response
 from ._utils import to_bytes, to_str, unquote
 
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from hashlib import _Hash
+
 
 class Auth:
     """
@@ -121,25 +126,51 @@ class BasicAuth(Auth):
     and uses HTTP Basic authentication.
     """
 
-    def __init__(
-        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
-    ):
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
         self._auth_header = self._build_auth_header(username, password)
 
     def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
         request.headers["Authorization"] = self._auth_header
         yield request
 
-    def _build_auth_header(
-        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
-    ) -> str:
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class NetRCAuth(Auth):
+    """
+    Use a 'netrc' file to lookup basic auth credentials based on the url host.
+    """
+
+    def __init__(self, file: str | None = None) -> None:
+        # Lazily import 'netrc'.
+        # There's no need for us to load this module unless 'NetRCAuth' is being used.
+        import netrc
+
+        self._netrc_info = netrc.netrc(file)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        auth_info = self._netrc_info.authenticators(request.url.host)
+        if auth_info is None or not auth_info[2]:
+            # The netrc file did not have authentication credentials for this host.
+            yield request
+        else:
+            # Build a basic auth header with credentials from the netrc file.
+            request.headers["Authorization"] = self._build_auth_header(
+                username=auth_info[0], password=auth_info[2]
+            )
+            yield request
+
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
         userpass = b":".join((to_bytes(username), to_bytes(password)))
         token = b64encode(userpass).decode()
         return f"Basic {token}"
 
 
 class DigestAuth(Auth):
-    _ALGORITHM_TO_HASH_FUNCTION: typing.Dict[str, typing.Callable] = {
+    _ALGORITHM_TO_HASH_FUNCTION: dict[str, typing.Callable[[bytes], _Hash]] = {
         "MD5": hashlib.md5,
         "MD5-SESS": hashlib.md5,
         "SHA": hashlib.sha1,
@@ -150,13 +181,18 @@ class DigestAuth(Auth):
         "SHA-512-SESS": hashlib.sha512,
     }
 
-    def __init__(
-        self, username: typing.Union[str, bytes], password: typing.Union[str, bytes]
-    ) -> None:
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
         self._username = to_bytes(username)
         self._password = to_bytes(password)
+        self._last_challenge: _DigestAuthChallenge | None = None
+        self._nonce_count = 1
 
     def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        if self._last_challenge:
+            request.headers["Authorization"] = self._build_auth_header(
+                request, self._last_challenge
+            )
+
         response = yield request
 
         if response.status_code != 401 or "www-authenticate" not in response.headers:
@@ -172,13 +208,19 @@ def auth_flow(self, request: Request) -> typing.Generator[Request, Response, Non
             # header, then we don't need to build an authenticated request.
             return
 
-        challenge = self._parse_challenge(request, response, auth_header)
-        request.headers["Authorization"] = self._build_auth_header(request, challenge)
+        self._last_challenge = self._parse_challenge(request, response, auth_header)
+        self._nonce_count = 1
+
+        request.headers["Authorization"] = self._build_auth_header(
+            request, self._last_challenge
+        )
+        if response.cookies:
+            Cookies(response.cookies).set_cookie_header(request=request)
         yield request
 
     def _parse_challenge(
         self, request: Request, response: Response, auth_header: str
-    ) -> "_DigestAuthChallenge":
+    ) -> _DigestAuthChallenge:
         """
         Returns a challenge from a Digest WWW-Authenticate header.
         These take the form of:
@@ -189,7 +231,7 @@ def _parse_challenge(
         # This method should only ever have been called with a Digest auth header.
         assert scheme.lower() == "digest"
 
-        header_dict: typing.Dict[str, str] = {}
+        header_dict: dict[str, str] = {}
         for field in parse_http_list(fields):
             key, value = field.strip().split("=", 1)
             header_dict[key] = unquote(value)
@@ -208,9 +250,9 @@ def _parse_challenge(
             raise ProtocolError(message, request=request) from exc
 
     def _build_auth_header(
-        self, request: Request, challenge: "_DigestAuthChallenge"
+        self, request: Request, challenge: _DigestAuthChallenge
     ) -> str:
-        hash_func = self._ALGORITHM_TO_HASH_FUNCTION[challenge.algorithm]
+        hash_func = self._ALGORITHM_TO_HASH_FUNCTION[challenge.algorithm.upper()]
 
         def digest(data: bytes) -> bytes:
             return hash_func(data).hexdigest().encode()
@@ -222,9 +264,9 @@ def digest(data: bytes) -> bytes:
         # TODO: implement auth-int
         HA2 = digest(A2)
 
-        nonce_count = 1  # TODO: implement nonce counting
-        nc_value = b"%08x" % nonce_count
-        cnonce = self._get_client_nonce(nonce_count, challenge.nonce)
+        nc_value = b"%08x" % self._nonce_count
+        cnonce = self._get_client_nonce(self._nonce_count, challenge.nonce)
+        self._nonce_count += 1
 
         HA1 = digest(A1)
         if challenge.algorithm.lower().endswith("-sess"):
@@ -232,17 +274,18 @@ def digest(data: bytes) -> bytes:
 
         qop = self._resolve_qop(challenge.qop, request=request)
         if qop is None:
+            # Following RFC 2069
             digest_data = [HA1, challenge.nonce, HA2]
         else:
-            digest_data = [challenge.nonce, nc_value, cnonce, qop, HA2]
-        key_digest = b":".join(digest_data)
+            # Following RFC 2617/7616
+            digest_data = [HA1, challenge.nonce, nc_value, cnonce, qop, HA2]
 
         format_args = {
             "username": self._username,
             "realm": challenge.realm,
             "nonce": challenge.nonce,
             "uri": path,
-            "response": digest(b":".join((HA1, key_digest))),
+            "response": digest(b":".join(digest_data)),
             "algorithm": challenge.algorithm.encode(),
         }
         if challenge.opaque:
@@ -262,7 +305,7 @@ def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
 
         return hashlib.sha1(s).hexdigest()[:16].encode()
 
-    def _get_header_value(self, header_fields: typing.Dict[str, bytes]) -> str:
+    def _get_header_value(self, header_fields: dict[str, bytes]) -> str:
         NON_QUOTED_FIELDS = ("algorithm", "qop", "nc")
         QUOTED_TEMPLATE = '{}="{}"'
         NON_QUOTED_TEMPLATE = "{}={}"
@@ -280,9 +323,7 @@ def _get_header_value(self, header_fields: typing.Dict[str, bytes]) -> str:
 
         return header_value
 
-    def _resolve_qop(
-        self, qop: typing.Optional[bytes], request: Request
-    ) -> typing.Optional[bytes]:
+    def _resolve_qop(self, qop: bytes | None, request: Request) -> bytes | None:
         if qop is None:
             return None
         qops = re.split(b", ?", qop)
@@ -300,5 +341,5 @@ class _DigestAuthChallenge(typing.NamedTuple):
     realm: bytes
     nonce: bytes
     algorithm: str
-    opaque: typing.Optional[bytes]
-    qop: typing.Optional[bytes]
+    opaque: bytes | None
+    qop: bytes | None
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_client.py b/addon/globalPlugins/spellcheck/libs/httpx/_client.py
index 9afe813..e2c6702 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_client.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_client.py
@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 import datetime
 import enum
+import logging
 import typing
 import warnings
-from contextlib import contextmanager
+from contextlib import asynccontextmanager, contextmanager
 from types import TracebackType
 
 from .__version__ import __version__
 from ._auth import Auth, BasicAuth, FunctionAuth
-from ._compat import asynccontextmanager
 from ._config import (
     DEFAULT_LIMITS,
     DEFAULT_MAX_REDIRECTS,
@@ -23,37 +25,36 @@
     TooManyRedirects,
     request_context,
 )
-from ._models import URL, Cookies, Headers, QueryParams, Request, Response
+from ._models import Cookies, Headers, Request, Response
 from ._status_codes import codes
 from ._transports.asgi import ASGITransport
-from ._transports.base import (
-    AsyncBaseTransport,
-    AsyncByteStream,
-    BaseTransport,
-    SyncByteStream,
-)
+from ._transports.base import AsyncBaseTransport, BaseTransport
 from ._transports.default import AsyncHTTPTransport, HTTPTransport
 from ._transports.wsgi import WSGITransport
 from ._types import (
+    AsyncByteStream,
     AuthTypes,
     CertTypes,
     CookieTypes,
     HeaderTypes,
     ProxiesTypes,
+    ProxyTypes,
     QueryParamTypes,
     RequestContent,
     RequestData,
+    RequestExtensions,
     RequestFiles,
+    SyncByteStream,
     TimeoutTypes,
     URLTypes,
     VerifyTypes,
 )
+from ._urls import URL, QueryParams
 from ._utils import (
-    NetRCInfo,
     Timer,
     URLPattern,
     get_environment_proxies,
-    get_logger,
+    is_https_redirect,
     same_origin,
 )
 
@@ -82,13 +83,11 @@ class UseClientDefault:
     but it is used internally when a parameter is not included.
     """
 
-    pass  # pragma: nocover
-
 
 USE_CLIENT_DEFAULT = UseClientDefault()
 
 
-logger = get_logger(__name__)
+logger = logging.getLogger("httpx")
 
 USER_AGENT = f"python-httpx/{__version__}"
 ACCEPT_ENCODING = ", ".join(
@@ -156,21 +155,25 @@ async def aclose(self) -> None:
         await self._stream.aclose()
 
 
+EventHook = typing.Callable[..., typing.Any]
+
+
 class BaseClient:
     def __init__(
         self,
         *,
-        auth: AuthTypes = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
         timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-        allow_redirects: bool = True,
+        follow_redirects: bool = False,
         max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: typing.Mapping[str, typing.List[typing.Callable]] = None,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
         base_url: URLTypes = "",
         trust_env: bool = True,
-    ):
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
         event_hooks = {} if event_hooks is None else event_hooks
 
         self._base_url = self._enforce_trailing_slash(URL(base_url))
@@ -180,14 +183,14 @@ def __init__(
         self.headers = Headers(headers)
         self._cookies = Cookies(cookies)
         self._timeout = Timeout(timeout)
-        self.allow_redirects = allow_redirects
+        self.follow_redirects = follow_redirects
         self.max_redirects = max_redirects
         self._event_hooks = {
             "request": list(event_hooks.get("request", [])),
             "response": list(event_hooks.get("response", [])),
         }
         self._trust_env = trust_env
-        self._netrc = NetRCInfo()
+        self._default_encoding = default_encoding
         self._state = ClientState.UNOPENED
 
     @property
@@ -207,8 +210,8 @@ def _enforce_trailing_slash(self, url: URL) -> URL:
         return url.copy_with(raw_path=url.raw_path + b"/")
 
     def _get_proxy_map(
-        self, proxies: typing.Optional[ProxiesTypes], allow_env_proxies: bool
-    ) -> typing.Dict[str, typing.Optional[Proxy]]:
+        self, proxies: ProxiesTypes | None, allow_env_proxies: bool
+    ) -> dict[str, Proxy | None]:
         if proxies is None:
             if allow_env_proxies:
                 return {
@@ -235,20 +238,18 @@ def timeout(self, timeout: TimeoutTypes) -> None:
         self._timeout = Timeout(timeout)
 
     @property
-    def event_hooks(self) -> typing.Dict[str, typing.List[typing.Callable]]:
+    def event_hooks(self) -> dict[str, list[EventHook]]:
         return self._event_hooks
 
     @event_hooks.setter
-    def event_hooks(
-        self, event_hooks: typing.Dict[str, typing.List[typing.Callable]]
-    ) -> None:
+    def event_hooks(self, event_hooks: dict[str, list[EventHook]]) -> None:
         self._event_hooks = {
             "request": list(event_hooks.get("request", [])),
             "response": list(event_hooks.get("response", [])),
         }
 
     @property
-    def auth(self) -> typing.Optional[Auth]:
+    def auth(self) -> Auth | None:
         """
         Authentication class used when none is passed at the request-level.
 
@@ -320,13 +321,15 @@ def build_request(
         method: str,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Request:
         """
         Build and return a request instance.
@@ -343,6 +346,14 @@ def build_request(
         headers = self._merge_headers(headers)
         cookies = self._merge_cookies(cookies)
         params = self._merge_queryparams(params)
+        extensions = {} if extensions is None else extensions
+        if "timeout" not in extensions:
+            timeout = (
+                self.timeout
+                if isinstance(timeout, UseClientDefault)
+                else Timeout(timeout)
+            )
+            extensions = dict(**extensions, timeout=timeout.as_dict())
         return Request(
             method,
             url,
@@ -353,6 +364,7 @@ def build_request(
             params=params,
             headers=headers,
             cookies=cookies,
+            extensions=extensions,
         )
 
     def _merge_url(self, url: URLTypes) -> URL:
@@ -364,7 +376,7 @@ def _merge_url(self, url: URLTypes) -> URL:
         if merge_url.is_relative_url:
             # To merge URLs we always append to the base URL. To get this
             # behaviour correct we always ensure the base URL ends in a '/'
-            # seperator, and strip any leading '/' from the merge URL.
+            # separator, and strip any leading '/' from the merge URL.
             #
             # So, eg...
             #
@@ -377,9 +389,7 @@ def _merge_url(self, url: URLTypes) -> URL:
             return self.base_url.copy_with(raw_path=merge_raw_path)
         return merge_url
 
-    def _merge_cookies(
-        self, cookies: CookieTypes = None
-    ) -> typing.Optional[CookieTypes]:
+    def _merge_cookies(self, cookies: CookieTypes | None = None) -> CookieTypes | None:
         """
         Merge a cookies argument together with any cookies on the client,
         to create the cookies used for the outgoing request.
@@ -390,9 +400,7 @@ def _merge_cookies(
             return merged_cookies
         return cookies
 
-    def _merge_headers(
-        self, headers: HeaderTypes = None
-    ) -> typing.Optional[HeaderTypes]:
+    def _merge_headers(self, headers: HeaderTypes | None = None) -> HeaderTypes | None:
         """
         Merge a headers argument together with any headers on the client,
         to create the headers used for the outgoing request.
@@ -402,19 +410,18 @@ def _merge_headers(
         return merged_headers
 
     def _merge_queryparams(
-        self, params: QueryParamTypes = None
-    ) -> typing.Optional[QueryParamTypes]:
+        self, params: QueryParamTypes | None = None
+    ) -> QueryParamTypes | None:
         """
         Merge a queryparams argument together with any queryparams on the client,
         to create the queryparams used for the outgoing request.
         """
         if params or self.params:
             merged_queryparams = QueryParams(self.params)
-            merged_queryparams = merged_queryparams.merge(params)
-            return merged_queryparams
+            return merged_queryparams.merge(params)
         return params
 
-    def _build_auth(self, auth: AuthTypes) -> typing.Optional[Auth]:
+    def _build_auth(self, auth: AuthTypes | None) -> Auth | None:
         if auth is None:
             return None
         elif isinstance(auth, tuple):
@@ -429,7 +436,7 @@ def _build_auth(self, auth: AuthTypes) -> typing.Optional[Auth]:
     def _build_request_auth(
         self,
         request: Request,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
     ) -> Auth:
         auth = (
             self._auth if isinstance(auth, UseClientDefault) else self._build_auth(auth)
@@ -442,11 +449,6 @@ def _build_request_auth(
         if username or password:
             return BasicAuth(username=username, password=password)
 
-        if self.trust_env and "Authorization" not in request.headers:
-            credentials = self._netrc.get_credentials(request.url.host)
-            if credentials is not None:
-                return BasicAuth(username=credentials[0], password=credentials[1])
-
         return Auth()
 
     def _build_redirect_request(self, request: Request, response: Response) -> Request:
@@ -460,7 +462,12 @@ def _build_redirect_request(self, request: Request, response: Response) -> Reque
         stream = self._redirect_stream(request, method)
         cookies = Cookies(self.cookies)
         return Request(
-            method=method, url=url, headers=headers, cookies=cookies, stream=stream
+            method=method,
+            url=url,
+            headers=headers,
+            cookies=cookies,
+            stream=stream,
+            extensions=request.extensions,
         )
 
     def _redirect_method(self, request: Request, response: Response) -> str:
@@ -522,9 +529,10 @@ def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
         headers = Headers(request.headers)
 
         if not same_origin(url, request.url):
-            # Strip Authorization headers when responses are redirected away from
-            # the origin.
-            headers.pop("Authorization", None)
+            if not is_https_redirect(request.url, url):
+                # Strip Authorization headers when responses are redirected
+                # away from the origin. (Except for direct HTTP to HTTPS redirects.)
+                headers.pop("Authorization", None)
 
             # Update the Host header.
             headers["Host"] = url.netloc.decode("ascii")
@@ -543,7 +551,7 @@ def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
 
     def _redirect_stream(
         self, request: Request, method: str
-    ) -> typing.Optional[typing.Union[SyncByteStream, AsyncByteStream]]:
+    ) -> SyncByteStream | AsyncByteStream | None:
         """
         Return the body that should be used for the redirect request.
         """
@@ -557,6 +565,8 @@ class Client(BaseClient):
     """
     An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc.
 
+    It can be shared between threads.
+
     Usage:
 
     ```python
@@ -582,6 +592,9 @@ class Client(BaseClient):
     to authenticate the client. Either a path to an SSL certificate file, or
     two-tuple of (certificate file, key file), or a three-tuple of (certificate
     file, key file, password).
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
     * **proxies** - *(optional)* A dictionary mapping proxy keys to proxy
     URLs.
     * **timeout** - *(optional)* The timeout configuration to use when sending
@@ -597,53 +610,77 @@ class Client(BaseClient):
     rather than sending actual network requests.
     * **trust_env** - *(optional)* Enables or disables usage of environment
     variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
     """
 
     def __init__(
         self,
         *,
-        auth: AuthTypes = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
-        proxies: ProxiesTypes = None,
-        mounts: typing.Mapping[str, BaseTransport] = None,
+        proxy: ProxyTypes | None = None,
+        proxies: ProxiesTypes | None = None,
+        mounts: None | (typing.Mapping[str, BaseTransport | None]) = None,
         timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
         limits: Limits = DEFAULT_LIMITS,
         max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: typing.Mapping[str, typing.List[typing.Callable]] = None,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
         base_url: URLTypes = "",
-        transport: BaseTransport = None,
-        app: typing.Callable = None,
+        transport: BaseTransport | None = None,
+        app: typing.Callable[..., typing.Any] | None = None,
         trust_env: bool = True,
-    ):
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
         super().__init__(
             auth=auth,
             params=params,
             headers=headers,
             cookies=cookies,
             timeout=timeout,
+            follow_redirects=follow_redirects,
             max_redirects=max_redirects,
             event_hooks=event_hooks,
             base_url=base_url,
             trust_env=trust_env,
+            default_encoding=default_encoding,
         )
 
         if http2:
             try:
                 import h2  # noqa
-            except ImportError:  # pragma: nocover
+            except ImportError:  # pragma: no cover
                 raise ImportError(
                     "Using http2=True, but the 'h2' package is not installed. "
                     "Make sure to install httpx using `pip install httpx[http2]`."
                 ) from None
 
+        if proxies:
+            message = (
+                "The 'proxies' argument is now deprecated."
+                " Use 'proxy' or 'mounts' instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+            if proxy:
+                raise RuntimeError("Use either `proxy` or 'proxies', not both.")
+
+        if app:
+            message = (
+                "The 'app' shortcut is now deprecated."
+                " Use the explicit style 'transport=WSGITransport(app=...)' instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+
         allow_env_proxies = trust_env and app is None and transport is None
-        proxy_map = self._get_proxy_map(proxies, allow_env_proxies)
+        proxy_map = self._get_proxy_map(proxies or proxy, allow_env_proxies)
 
         self._transport = self._init_transport(
             verify=verify,
@@ -655,7 +692,7 @@ def __init__(
             app=app,
             trust_env=trust_env,
         )
-        self._mounts: typing.Dict[URLPattern, typing.Optional[BaseTransport]] = {
+        self._mounts: dict[URLPattern, BaseTransport | None] = {
             URLPattern(key): None
             if proxy is None
             else self._init_proxy_transport(
@@ -679,12 +716,12 @@ def __init__(
     def _init_transport(
         self,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
-        transport: BaseTransport = None,
-        app: typing.Callable = None,
+        transport: BaseTransport | None = None,
+        app: typing.Callable[..., typing.Any] | None = None,
         trust_env: bool = True,
     ) -> BaseTransport:
         if transport is not None:
@@ -706,7 +743,7 @@ def _init_proxy_transport(
         self,
         proxy: Proxy,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
@@ -738,16 +775,17 @@ def request(
         method: str,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Build and send a request.
@@ -783,10 +821,10 @@ def request(
             params=params,
             headers=headers,
             cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
         )
-        return self.send(
-            request, auth=auth, allow_redirects=allow_redirects, timeout=timeout
-        )
+        return self.send(request, auth=auth, follow_redirects=follow_redirects)
 
     @contextmanager
     def stream(
@@ -794,16 +832,17 @@ def stream(
         method: str,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> typing.Iterator[Response]:
         """
         Alternative to `httpx.request()` that streams the response body
@@ -825,12 +864,13 @@ def stream(
             params=params,
             headers=headers,
             cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
         )
         response = self.send(
             request=request,
             auth=auth,
-            allow_redirects=allow_redirects,
-            timeout=timeout,
+            follow_redirects=follow_redirects,
             stream=True,
         )
         try:
@@ -843,9 +883,8 @@ def send(
         request: Request,
         *,
         stream: bool = False,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
     ) -> Response:
         """
         Send a request.
@@ -864,13 +903,10 @@ def send(
             raise RuntimeError("Cannot send a request, as the client has been closed.")
 
         self._state = ClientState.OPENED
-        timeout = (
-            self.timeout if isinstance(timeout, UseClientDefault) else Timeout(timeout)
-        )
-        allow_redirects = (
-            self.allow_redirects
-            if isinstance(allow_redirects, UseClientDefault)
-            else allow_redirects
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
         )
 
         auth = self._build_request_auth(request, auth)
@@ -878,8 +914,7 @@ def send(
         response = self._send_handling_auth(
             request,
             auth=auth,
-            timeout=timeout,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             history=[],
         )
         try:
@@ -888,7 +923,7 @@ def send(
 
             return response
 
-        except Exception as exc:
+        except BaseException as exc:
             response.close()
             raise exc
 
@@ -896,9 +931,8 @@ def _send_handling_auth(
         self,
         request: Request,
         auth: Auth,
-        timeout: Timeout,
-        allow_redirects: bool,
-        history: typing.List[Response],
+        follow_redirects: bool,
+        history: list[Response],
     ) -> Response:
         auth_flow = auth.sync_auth_flow(request)
         try:
@@ -907,8 +941,7 @@ def _send_handling_auth(
             while True:
                 response = self._send_handling_redirects(
                     request,
-                    timeout=timeout,
-                    allow_redirects=allow_redirects,
+                    follow_redirects=follow_redirects,
                     history=history,
                 )
                 try:
@@ -922,7 +955,7 @@ def _send_handling_auth(
                     request = next_request
                     history.append(response)
 
-                except Exception as exc:
+                except BaseException as exc:
                     response.close()
                     raise exc
         finally:
@@ -931,9 +964,8 @@ def _send_handling_auth(
     def _send_handling_redirects(
         self,
         request: Request,
-        timeout: Timeout,
-        allow_redirects: bool,
-        history: typing.List[Response],
+        follow_redirects: bool,
+        history: list[Response],
     ) -> Response:
         while True:
             if len(history) > self.max_redirects:
@@ -944,29 +976,29 @@ def _send_handling_redirects(
             for hook in self._event_hooks["request"]:
                 hook(request)
 
-            response = self._send_single_request(request, timeout)
+            response = self._send_single_request(request)
             try:
                 for hook in self._event_hooks["response"]:
                     hook(response)
                 response.history = list(history)
 
-                if not response.is_redirect:
+                if not response.has_redirect_location:
                     return response
 
                 request = self._build_redirect_request(request, response)
                 history = history + [response]
 
-                if allow_redirects:
+                if follow_redirects:
                     response.read()
                 else:
                     response.next_request = request
                     return response
 
-            except Exception as exc:
+            except BaseException as exc:
                 response.close()
                 raise exc
 
-    def _send_single_request(self, request: Request, timeout: Timeout) -> Response:
+    def _send_single_request(self, request: Request) -> Response:
         """
         Sends a single request, without handling any redirections.
         """
@@ -980,28 +1012,25 @@ def _send_single_request(self, request: Request, timeout: Timeout) -> Response:
             )
 
         with request_context(request=request):
-            (status_code, headers, stream, extensions) = transport.handle_request(
-                request.method.encode(),
-                request.url.raw,
-                headers=request.headers.raw,
-                stream=request.stream,
-                extensions={"timeout": timeout.as_dict()},
-            )
+            response = transport.handle_request(request)
 
-        response = Response(
-            status_code,
-            headers=headers,
-            stream=stream,
-            extensions=extensions,
-            request=request,
-        )
+        assert isinstance(response.stream, SyncByteStream)
 
-        response.stream = BoundSyncStream(stream, response=response, timer=timer)
+        response.request = request
+        response.stream = BoundSyncStream(
+            response.stream, response=response, timer=timer
+        )
         self.cookies.extract_cookies(response)
-
-        status = f"{response.status_code} {response.reason_phrase}"
-        response_line = f"{response.http_version} {status}"
-        logger.debug(f'HTTP Request: {request.method} {request.url} "{response_line}"')
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
 
         return response
 
@@ -1009,12 +1038,13 @@ def get(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `GET` request.
@@ -1028,20 +1058,22 @@ def get(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def options(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send an `OPTIONS` request.
@@ -1055,20 +1087,22 @@ def options(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def head(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `HEAD` request.
@@ -1082,24 +1116,26 @@ def head(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def post(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `POST` request.
@@ -1117,24 +1153,26 @@ def post(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def put(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `PUT` request.
@@ -1152,24 +1190,26 @@ def put(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def patch(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `PATCH` request.
@@ -1187,20 +1227,22 @@ def patch(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def delete(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `DELETE` request.
@@ -1214,8 +1256,9 @@ def delete(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     def close(self) -> None:
@@ -1234,7 +1277,9 @@ def __enter__(self: T) -> T:
         if self._state != ClientState.UNOPENED:
             msg = {
                 ClientState.OPENED: "Cannot open a client instance more than once.",
-                ClientState.CLOSED: "Cannot reopen a client instance, once it has been closed.",
+                ClientState.CLOSED: (
+                    "Cannot reopen a client instance, once it has been closed."
+                ),
             }[self._state]
             raise RuntimeError(msg)
 
@@ -1248,9 +1293,9 @@ def __enter__(self: T) -> T:
 
     def __exit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         self._state = ClientState.CLOSED
 
@@ -1259,19 +1304,14 @@ def __exit__(
             if transport is not None:
                 transport.__exit__(exc_type, exc_value, traceback)
 
-    def __del__(self) -> None:
-        # We use 'getattr' here, to manage the case where '__del__()' is called
-        # on a partically initiallized instance that raised an exception during
-        # the call to '__init__()'.
-        if getattr(self, "_state", None) == ClientState.OPENED:  # noqa: B009
-            self.close()
-
 
 class AsyncClient(BaseClient):
     """
     An asynchronous HTTP client, with connection pooling, HTTP/2, redirects,
     cookie persistence, etc.
 
+    It can be shared between tasks.
+
     Usage:
 
     ```python
@@ -1291,13 +1331,15 @@ class AsyncClient(BaseClient):
     sending requests.
     * **verify** - *(optional)* SSL certificates (a.k.a CA bundle) used to
     verify the identity of requested hosts. Either `True` (default CA bundle),
-    a path to an SSL certificate file, or `False` (disable verification).
+    a path to an SSL certificate file, an `ssl.SSLContext`, or `False`
+    (which will disable verification).
     * **cert** - *(optional)* An SSL certificate used by the requested host
     to authenticate the client. Either a path to an SSL certificate file, or
     two-tuple of (certificate file, key file), or a three-tuple of (certificate
     file, key file, password).
     * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
     enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
     * **proxies** - *(optional)* A dictionary mapping HTTP protocols to proxy
     URLs.
     * **timeout** - *(optional)* The timeout configuration to use when sending
@@ -1313,53 +1355,78 @@ class AsyncClient(BaseClient):
     rather than sending actual network requests.
     * **trust_env** - *(optional)* Enables or disables usage of environment
     variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
     """
 
     def __init__(
         self,
         *,
-        auth: AuthTypes = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
-        proxies: ProxiesTypes = None,
-        mounts: typing.Mapping[str, AsyncBaseTransport] = None,
+        proxy: ProxyTypes | None = None,
+        proxies: ProxiesTypes | None = None,
+        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
         timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
         limits: Limits = DEFAULT_LIMITS,
         max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: typing.Mapping[str, typing.List[typing.Callable]] = None,
+        event_hooks: None
+        | (typing.Mapping[str, list[typing.Callable[..., typing.Any]]]) = None,
         base_url: URLTypes = "",
-        transport: AsyncBaseTransport = None,
-        app: typing.Callable = None,
+        transport: AsyncBaseTransport | None = None,
+        app: typing.Callable[..., typing.Any] | None = None,
         trust_env: bool = True,
-    ):
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
         super().__init__(
             auth=auth,
             params=params,
             headers=headers,
             cookies=cookies,
             timeout=timeout,
+            follow_redirects=follow_redirects,
             max_redirects=max_redirects,
             event_hooks=event_hooks,
             base_url=base_url,
             trust_env=trust_env,
+            default_encoding=default_encoding,
         )
 
         if http2:
             try:
                 import h2  # noqa
-            except ImportError:  # pragma: nocover
+            except ImportError:  # pragma: no cover
                 raise ImportError(
                     "Using http2=True, but the 'h2' package is not installed. "
                     "Make sure to install httpx using `pip install httpx[http2]`."
                 ) from None
 
-        allow_env_proxies = trust_env and app is None and transport is None
-        proxy_map = self._get_proxy_map(proxies, allow_env_proxies)
+        if proxies:
+            message = (
+                "The 'proxies' argument is now deprecated."
+                " Use 'proxy' or 'mounts' instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+            if proxy:
+                raise RuntimeError("Use either `proxy` or 'proxies', not both.")
+
+        if app:
+            message = (
+                "The 'app' shortcut is now deprecated."
+                " Use the explicit style 'transport=ASGITransport(app=...)' instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+
+        allow_env_proxies = trust_env and transport is None
+        proxy_map = self._get_proxy_map(proxies or proxy, allow_env_proxies)
 
         self._transport = self._init_transport(
             verify=verify,
@@ -1372,7 +1439,7 @@ def __init__(
             trust_env=trust_env,
         )
 
-        self._mounts: typing.Dict[URLPattern, typing.Optional[AsyncBaseTransport]] = {
+        self._mounts: dict[URLPattern, AsyncBaseTransport | None] = {
             URLPattern(key): None
             if proxy is None
             else self._init_proxy_transport(
@@ -1395,12 +1462,12 @@ def __init__(
     def _init_transport(
         self,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
-        transport: AsyncBaseTransport = None,
-        app: typing.Callable = None,
+        transport: AsyncBaseTransport | None = None,
+        app: typing.Callable[..., typing.Any] | None = None,
         trust_env: bool = True,
     ) -> AsyncBaseTransport:
         if transport is not None:
@@ -1422,7 +1489,7 @@ def _init_proxy_transport(
         self,
         proxy: Proxy,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
@@ -1431,6 +1498,7 @@ def _init_proxy_transport(
         return AsyncHTTPTransport(
             verify=verify,
             cert=cert,
+            http1=http1,
             http2=http2,
             limits=limits,
             trust_env=trust_env,
@@ -1453,16 +1521,17 @@ async def request(
         method: str,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Build and send a request.
@@ -1480,6 +1549,15 @@ async def request(
 
         [0]: /advanced/#merging-of-configuration
         """
+
+        if cookies is not None:  # pragma: no cover
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning)
+
         request = self.build_request(
             method=method,
             url=url,
@@ -1490,11 +1568,10 @@ async def request(
             params=params,
             headers=headers,
             cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
         )
-        response = await self.send(
-            request, auth=auth, allow_redirects=allow_redirects, timeout=timeout
-        )
-        return response
+        return await self.send(request, auth=auth, follow_redirects=follow_redirects)
 
     @asynccontextmanager
     async def stream(
@@ -1502,16 +1579,17 @@ async def stream(
         method: str,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> typing.AsyncIterator[Response]:
         """
         Alternative to `httpx.request()` that streams the response body
@@ -1533,12 +1611,13 @@ async def stream(
             params=params,
             headers=headers,
             cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
         )
         response = await self.send(
             request=request,
             auth=auth,
-            allow_redirects=allow_redirects,
-            timeout=timeout,
+            follow_redirects=follow_redirects,
             stream=True,
         )
         try:
@@ -1551,9 +1630,8 @@ async def send(
         request: Request,
         *,
         stream: bool = False,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
     ) -> Response:
         """
         Send a request.
@@ -1572,13 +1650,10 @@ async def send(
             raise RuntimeError("Cannot send a request, as the client has been closed.")
 
         self._state = ClientState.OPENED
-        timeout = (
-            self.timeout if isinstance(timeout, UseClientDefault) else Timeout(timeout)
-        )
-        allow_redirects = (
-            self.allow_redirects
-            if isinstance(allow_redirects, UseClientDefault)
-            else allow_redirects
+        follow_redirects = (
+            self.follow_redirects
+            if isinstance(follow_redirects, UseClientDefault)
+            else follow_redirects
         )
 
         auth = self._build_request_auth(request, auth)
@@ -1586,8 +1661,7 @@ async def send(
         response = await self._send_handling_auth(
             request,
             auth=auth,
-            timeout=timeout,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             history=[],
         )
         try:
@@ -1596,7 +1670,7 @@ async def send(
 
             return response
 
-        except Exception as exc:  # pragma: no cover
+        except BaseException as exc:
             await response.aclose()
             raise exc
 
@@ -1604,9 +1678,8 @@ async def _send_handling_auth(
         self,
         request: Request,
         auth: Auth,
-        timeout: Timeout,
-        allow_redirects: bool,
-        history: typing.List[Response],
+        follow_redirects: bool,
+        history: list[Response],
     ) -> Response:
         auth_flow = auth.async_auth_flow(request)
         try:
@@ -1615,8 +1688,7 @@ async def _send_handling_auth(
             while True:
                 response = await self._send_handling_redirects(
                     request,
-                    timeout=timeout,
-                    allow_redirects=allow_redirects,
+                    follow_redirects=follow_redirects,
                     history=history,
                 )
                 try:
@@ -1630,7 +1702,7 @@ async def _send_handling_auth(
                     request = next_request
                     history.append(response)
 
-                except Exception as exc:
+                except BaseException as exc:
                     await response.aclose()
                     raise exc
         finally:
@@ -1639,9 +1711,8 @@ async def _send_handling_auth(
     async def _send_handling_redirects(
         self,
         request: Request,
-        timeout: Timeout,
-        allow_redirects: bool,
-        history: typing.List[Response],
+        follow_redirects: bool,
+        history: list[Response],
     ) -> Response:
         while True:
             if len(history) > self.max_redirects:
@@ -1652,32 +1723,30 @@ async def _send_handling_redirects(
             for hook in self._event_hooks["request"]:
                 await hook(request)
 
-            response = await self._send_single_request(request, timeout)
+            response = await self._send_single_request(request)
             try:
                 for hook in self._event_hooks["response"]:
                     await hook(response)
 
                 response.history = list(history)
 
-                if not response.is_redirect:
+                if not response.has_redirect_location:
                     return response
 
                 request = self._build_redirect_request(request, response)
                 history = history + [response]
 
-                if allow_redirects:
+                if follow_redirects:
                     await response.aread()
                 else:
                     response.next_request = request
                     return response
 
-            except Exception as exc:
+            except BaseException as exc:
                 await response.aclose()
                 raise exc
 
-    async def _send_single_request(
-        self, request: Request, timeout: Timeout
-    ) -> Response:
+    async def _send_single_request(self, request: Request) -> Response:
         """
         Sends a single request, without handling any redirections.
         """
@@ -1691,33 +1760,24 @@ async def _send_single_request(
             )
 
         with request_context(request=request):
-            (
-                status_code,
-                headers,
-                stream,
-                extensions,
-            ) = await transport.handle_async_request(
-                request.method.encode(),
-                request.url.raw,
-                headers=request.headers.raw,
-                stream=request.stream,
-                extensions={"timeout": timeout.as_dict()},
-            )
+            response = await transport.handle_async_request(request)
 
-        response = Response(
-            status_code,
-            headers=headers,
-            stream=stream,
-            extensions=extensions,
-            request=request,
+        assert isinstance(response.stream, AsyncByteStream)
+        response.request = request
+        response.stream = BoundAsyncStream(
+            response.stream, response=response, timer=timer
         )
-
-        response.stream = BoundAsyncStream(stream, response=response, timer=timer)
         self.cookies.extract_cookies(response)
-
-        status = f"{response.status_code} {response.reason_phrase}"
-        response_line = f"{response.http_version} {status}"
-        logger.debug(f'HTTP Request: {request.method} {request.url} "{response_line}"')
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
 
         return response
 
@@ -1725,12 +1785,13 @@ async def get(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `GET` request.
@@ -1744,20 +1805,22 @@ async def get(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def options(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send an `OPTIONS` request.
@@ -1771,20 +1834,22 @@ async def options(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def head(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `HEAD` request.
@@ -1798,24 +1863,26 @@ async def head(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def post(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `POST` request.
@@ -1833,24 +1900,26 @@ async def post(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def put(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `PUT` request.
@@ -1868,24 +1937,26 @@ async def put(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def patch(
         self,
         url: URLTypes,
         *,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `PATCH` request.
@@ -1903,20 +1974,22 @@ async def patch(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def delete(
         self,
         url: URLTypes,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        auth: typing.Union[AuthTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
-        allow_redirects: typing.Union[bool, UseClientDefault] = USE_CLIENT_DEFAULT,
-        timeout: typing.Union[TimeoutTypes, UseClientDefault] = USE_CLIENT_DEFAULT,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
     ) -> Response:
         """
         Send a `DELETE` request.
@@ -1930,8 +2003,9 @@ async def delete(
             headers=headers,
             cookies=cookies,
             auth=auth,
-            allow_redirects=allow_redirects,
+            follow_redirects=follow_redirects,
             timeout=timeout,
+            extensions=extensions,
         )
 
     async def aclose(self) -> None:
@@ -1950,7 +2024,9 @@ async def __aenter__(self: U) -> U:
         if self._state != ClientState.UNOPENED:
             msg = {
                 ClientState.OPENED: "Cannot open a client instance more than once.",
-                ClientState.CLOSED: "Cannot reopen a client instance, once it has been closed.",
+                ClientState.CLOSED: (
+                    "Cannot reopen a client instance, once it has been closed."
+                ),
             }[self._state]
             raise RuntimeError(msg)
 
@@ -1964,9 +2040,9 @@ async def __aenter__(self: U) -> U:
 
     async def __aexit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         self._state = ClientState.CLOSED
 
@@ -1974,34 +2050,3 @@ async def __aexit__(
         for proxy in self._mounts.values():
             if proxy is not None:
                 await proxy.__aexit__(exc_type, exc_value, traceback)
-
-    def __del__(self) -> None:
-        # We use 'getattr' here, to manage the case where '__del__()' is called
-        # on a partically initiallized instance that raised an exception during
-        # the call to '__init__()'.
-        if getattr(self, "_state", None) == ClientState.OPENED:  # noqa: B009
-            # Unlike the sync case, we cannot silently close the client when
-            # it is garbage collected, because `.aclose()` is an async operation,
-            # but `__del__` is not.
-            #
-            # For this reason we require explicit close management for
-            # `AsyncClient`, and issue a warning on unclosed clients.
-            #
-            # The context managed style is usually preferable, because it neatly
-            # ensures proper resource cleanup:
-            #
-            #     async with httpx.AsyncClient() as client:
-            #         ...
-            #
-            # However, an explicit call to `aclose()` is also sufficient:
-            #
-            #    client = httpx.AsyncClient()
-            #    try:
-            #        ...
-            #    finally:
-            #        await client.aclose()
-            warnings.warn(
-                f"Unclosed {self!r}. "
-                "See https://www.python-httpx.org/async/#opening-and-closing-clients "
-                "for details."
-            )
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_compat.py b/addon/globalPlugins/spellcheck/libs/httpx/_compat.py
index 15e915a..493e621 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_compat.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_compat.py
@@ -5,27 +5,18 @@
 import ssl
 import sys
 
-# `contextlib.asynccontextmanager` exists from Python 3.7 onwards.
-# For 3.6 we require the `async_generator` package for a backported version.
-try:
-    from contextlib import asynccontextmanager  # type: ignore
-except ImportError:
-    from async_generator import asynccontextmanager  # type: ignore # noqa
-
 # Brotli support is optional
 # The C bindings in `brotli` are recommended for CPython.
 # The CFFI bindings in `brotlicffi` are recommended for PyPy and everything else.
 try:
     import brotlicffi as brotli
-except ImportError:  # pragma: nocover
+except ImportError:  # pragma: no cover
     try:
         import brotli
     except ImportError:
         brotli = None
 
-if sys.version_info >= (3, 10) or (
-    sys.version_info >= (3, 7) and ssl.OPENSSL_VERSION_INFO >= (1, 1, 0, 7)
-):
+if sys.version_info >= (3, 10) or ssl.OPENSSL_VERSION_INFO >= (1, 1, 0, 7):
 
     def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
         # The OP_NO_SSL* and OP_NO_TLS* become deprecated in favor of
@@ -36,7 +27,6 @@ def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
         # https://docs.python.org/3.7/library/ssl.html#ssl.SSLContext.minimum_version
         context.minimum_version = ssl.TLSVersion.TLSv1_2
 
-
 else:
 
     def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
@@ -46,3 +36,6 @@ def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
         context.options |= ssl.OP_NO_SSLv3
         context.options |= ssl.OP_NO_TLSv1
         context.options |= ssl.OP_NO_TLSv1_1
+
+
+__all__ = ["brotli", "set_minimum_tls_version_1_2"]
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_config.py b/addon/globalPlugins/spellcheck/libs/httpx/_config.py
index 927a67c..7636a5d 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_config.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_config.py
@@ -1,15 +1,18 @@
+from __future__ import annotations
+
+import logging
 import os
 import ssl
 import typing
-from base64 import b64encode
 from pathlib import Path
 
 import certifi
 
 from ._compat import set_minimum_tls_version_1_2
-from ._models import URL, Headers
+from ._models import Headers
 from ._types import CertTypes, HeaderTypes, TimeoutTypes, URLTypes, VerifyTypes
-from ._utils import get_ca_bundle_from_env, get_logger
+from ._urls import URL
+from ._utils import get_ca_bundle_from_env
 
 DEFAULT_CIPHERS = ":".join(
     [
@@ -31,18 +34,18 @@
 )
 
 
-logger = get_logger(__name__)
+logger = logging.getLogger("httpx")
 
 
 class UnsetType:
-    pass  # pragma: nocover
+    pass  # pragma: no cover
 
 
 UNSET = UnsetType()
 
 
 def create_ssl_context(
-    cert: CertTypes = None,
+    cert: CertTypes | None = None,
     verify: VerifyTypes = True,
     trust_env: bool = True,
     http2: bool = False,
@@ -62,11 +65,11 @@ class SSLConfig:
     def __init__(
         self,
         *,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         verify: VerifyTypes = True,
         trust_env: bool = True,
         http2: bool = False,
-    ):
+    ) -> None:
         self.cert = cert
         self.verify = verify
         self.trust_env = trust_env
@@ -74,12 +77,12 @@ def __init__(
         self.ssl_context = self.load_ssl_context()
 
     def load_ssl_context(self) -> ssl.SSLContext:
-        logger.trace(
-            f"load_ssl_context "
-            f"verify={self.verify!r} "
-            f"cert={self.cert!r} "
-            f"trust_env={self.trust_env!r} "
-            f"http2={self.http2!r}"
+        logger.debug(
+            "load_ssl_context verify=%r cert=%r trust_env=%r http2=%r",
+            self.verify,
+            self.cert,
+            self.trust_env,
+            self.http2,
         )
 
         if self.verify:
@@ -127,23 +130,25 @@ def load_ssl_context_verify(self) -> ssl.SSLContext:
         # Signal to server support for PHA in TLS 1.3. Raises an
         # AttributeError if only read-only access is implemented.
         try:
-            context.post_handshake_auth = True  # type: ignore
-        except AttributeError:  # pragma: nocover
+            context.post_handshake_auth = True
+        except AttributeError:  # pragma: no cover
             pass
 
         # Disable using 'commonName' for SSLContext.check_hostname
         # when the 'subjectAltName' extension isn't available.
         try:
-            context.hostname_checks_common_name = False  # type: ignore
-        except AttributeError:  # pragma: nocover
+            context.hostname_checks_common_name = False
+        except AttributeError:  # pragma: no cover
             pass
 
         if ca_bundle_path.is_file():
-            logger.trace(f"load_verify_locations cafile={ca_bundle_path!s}")
-            context.load_verify_locations(cafile=str(ca_bundle_path))
+            cafile = str(ca_bundle_path)
+            logger.debug("load_verify_locations cafile=%r", cafile)
+            context.load_verify_locations(cafile=cafile)
         elif ca_bundle_path.is_dir():
-            logger.trace(f"load_verify_locations capath={ca_bundle_path!s}")
-            context.load_verify_locations(capath=str(ca_bundle_path))
+            capath = str(ca_bundle_path)
+            logger.debug("load_verify_locations capath=%r", capath)
+            context.load_verify_locations(capath=capath)
 
         self._load_client_certs(context)
 
@@ -163,10 +168,9 @@ def _create_default_ssl_context(self) -> ssl.SSLContext:
             alpn_idents = ["http/1.1", "h2"] if self.http2 else ["http/1.1"]
             context.set_alpn_protocols(alpn_idents)
 
-        if hasattr(context, "keylog_filename"):  # pragma: nocover (Available in 3.8+)
-            keylogfile = os.environ.get("SSLKEYLOGFILE")
-            if keylogfile and self.trust_env:
-                context.keylog_filename = keylogfile  # type: ignore
+        keylogfile = os.environ.get("SSLKEYLOGFILE")
+        if keylogfile and self.trust_env:
+            context.keylog_filename = keylogfile
 
         return context
 
@@ -183,7 +187,7 @@ def _load_client_certs(self, ssl_context: ssl.SSLContext) -> None:
                 ssl_context.load_cert_chain(
                     certfile=self.cert[0],
                     keyfile=self.cert[1],
-                    password=self.cert[2],  # type: ignore
+                    password=self.cert[2],
                 )
 
 
@@ -203,13 +207,13 @@ class Timeout:
 
     def __init__(
         self,
-        timeout: typing.Union[TimeoutTypes, UnsetType] = UNSET,
+        timeout: TimeoutTypes | UnsetType = UNSET,
         *,
-        connect: typing.Union[None, float, UnsetType] = UNSET,
-        read: typing.Union[None, float, UnsetType] = UNSET,
-        write: typing.Union[None, float, UnsetType] = UNSET,
-        pool: typing.Union[None, float, UnsetType] = UNSET,
-    ):
+        connect: None | float | UnsetType = UNSET,
+        read: None | float | UnsetType = UNSET,
+        write: None | float | UnsetType = UNSET,
+        pool: None | float | UnsetType = UNSET,
+    ) -> None:
         if isinstance(timeout, Timeout):
             # Passed as a single explicit Timeout.
             assert connect is UNSET
@@ -247,7 +251,7 @@ def __init__(
             self.write = timeout if isinstance(write, UnsetType) else write
             self.pool = timeout if isinstance(pool, UnsetType) else pool
 
-    def as_dict(self) -> typing.Dict[str, typing.Optional[float]]:
+    def as_dict(self) -> dict[str, float | None]:
         return {
             "connect": self.connect,
             "read": self.read,
@@ -285,15 +289,16 @@ class Limits:
     * **max_keepalive_connections** - Allow the connection pool to maintain
             keep-alive connections below this point. Should be less than or equal
             to `max_connections`.
+    * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds.
     """
 
     def __init__(
         self,
         *,
-        max_connections: int = None,
-        max_keepalive_connections: int = None,
-        keepalive_expiry: typing.Optional[float] = 5.0,
-    ):
+        max_connections: int | None = None,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = 5.0,
+    ) -> None:
         self.max_connections = max_connections
         self.max_keepalive_connections = max_keepalive_connections
         self.keepalive_expiry = keepalive_expiry
@@ -316,32 +321,48 @@ def __repr__(self) -> str:
 
 
 class Proxy:
-    def __init__(self, url: URLTypes, *, headers: HeaderTypes = None):
+    def __init__(
+        self,
+        url: URLTypes,
+        *,
+        ssl_context: ssl.SSLContext | None = None,
+        auth: tuple[str, str] | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> None:
         url = URL(url)
         headers = Headers(headers)
 
-        if url.scheme not in ("http", "https"):
+        if url.scheme not in ("http", "https", "socks5"):
             raise ValueError(f"Unknown scheme for proxy URL {url!r}")
 
         if url.username or url.password:
-            headers.setdefault(
-                "Proxy-Authorization",
-                self._build_auth_header(url.username, url.password),
-            )
-            # Remove userinfo from the URL authority, e.g.:
-            # 'username:password@proxy_host:proxy_port' -> 'proxy_host:proxy_port'
+            # Remove any auth credentials from the URL.
+            auth = (url.username, url.password)
             url = url.copy_with(username=None, password=None)
 
         self.url = url
+        self.auth = auth
         self.headers = headers
+        self.ssl_context = ssl_context
 
-    def _build_auth_header(self, username: str, password: str) -> str:
-        userpass = (username.encode("utf-8"), password.encode("utf-8"))
-        token = b64encode(b":".join(userpass)).decode()
-        return f"Basic {token}"
+    @property
+    def raw_auth(self) -> tuple[bytes, bytes] | None:
+        # The proxy authentication as raw bytes.
+        return (
+            None
+            if self.auth is None
+            else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8"))
+        )
 
     def __repr__(self) -> str:
-        return f"Proxy(url={str(self.url)!r}, headers={dict(self.headers)!r})"
+        # The authentication is represented with the password component masked.
+        auth = (self.auth[0], "********") if self.auth else None
+
+        # Build a nice concise representation.
+        url_str = f"{str(self.url)!r}"
+        auth_str = f", auth={auth!r}" if auth else ""
+        headers_str = f", headers={dict(self.headers)!r}" if self.headers else ""
+        return f"Proxy({url_str}{auth_str}{headers_str})"
 
 
 DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0)
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_content.py b/addon/globalPlugins/spellcheck/libs/httpx/_content.py
index 86f3c7c..10b574b 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_content.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_content.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import inspect
 import warnings
 from json import dumps as json_dumps
@@ -5,18 +7,22 @@
     Any,
     AsyncIterable,
     AsyncIterator,
-    Dict,
     Iterable,
     Iterator,
-    Tuple,
-    Union,
+    Mapping,
 )
 from urllib.parse import urlencode
 
 from ._exceptions import StreamClosed, StreamConsumed
 from ._multipart import MultipartStream
-from ._transports.base import AsyncByteStream, SyncByteStream
-from ._types import RequestContent, RequestData, RequestFiles, ResponseContent
+from ._types import (
+    AsyncByteStream,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    ResponseContent,
+    SyncByteStream,
+)
 from ._utils import peek_filelike_length, primitive_value_to_str
 
 
@@ -32,7 +38,9 @@ async def __aiter__(self) -> AsyncIterator[bytes]:
 
 
 class IteratorByteStream(SyncByteStream):
-    def __init__(self, stream: Iterable[bytes]):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: Iterable[bytes]) -> None:
         self._stream = stream
         self._is_stream_consumed = False
         self._is_generator = inspect.isgenerator(stream)
@@ -42,12 +50,22 @@ def __iter__(self) -> Iterator[bytes]:
             raise StreamConsumed()
 
         self._is_stream_consumed = True
-        for part in self._stream:
-            yield part
+        if hasattr(self._stream, "read"):
+            # File-like interfaces should use 'read' directly.
+            chunk = self._stream.read(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = self._stream.read(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate.
+            for part in self._stream:
+                yield part
 
 
 class AsyncIteratorByteStream(AsyncByteStream):
-    def __init__(self, stream: AsyncIterable[bytes]):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: AsyncIterable[bytes]) -> None:
         self._stream = stream
         self._is_stream_consumed = False
         self._is_generator = inspect.isasyncgen(stream)
@@ -57,8 +75,16 @@ async def __aiter__(self) -> AsyncIterator[bytes]:
             raise StreamConsumed()
 
         self._is_stream_consumed = True
-        async for part in self._stream:
-            yield part
+        if hasattr(self._stream, "aread"):
+            # File-like interfaces should use 'aread' directly.
+            chunk = await self._stream.aread(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = await self._stream.aread(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate.
+            async for part in self._stream:
+                yield part
 
 
 class UnattachedStream(AsyncByteStream, SyncByteStream):
@@ -73,20 +99,23 @@ def __iter__(self) -> Iterator[bytes]:
 
     async def __aiter__(self) -> AsyncIterator[bytes]:
         raise StreamClosed()
-        yield b""  # pragma: nocover
+        yield b""  # pragma: no cover
 
 
 def encode_content(
-    content: Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
-) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
-
+    content: str | bytes | Iterable[bytes] | AsyncIterable[bytes],
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
     if isinstance(content, (bytes, str)):
         body = content.encode("utf-8") if isinstance(content, str) else content
         content_length = len(body)
         headers = {"Content-Length": str(content_length)} if body else {}
         return headers, ByteStream(body)
 
-    elif isinstance(content, Iterable):
+    elif isinstance(content, Iterable) and not isinstance(content, dict):
+        # `not isinstance(content, dict)` is a bit oddly specific, but it
+        # catches a case that's easy for users to make in error, and would
+        # otherwise pass through here, like any other bytes-iterable,
+        # because `dict` happens to be iterable. See issue #2491.
         content_length_or_none = peek_filelike_length(content)
 
         if content_length_or_none is None:
@@ -103,8 +132,8 @@ def encode_content(
 
 
 def encode_urlencoded_data(
-    data: dict,
-) -> Tuple[Dict[str, str], ByteStream]:
+    data: RequestData,
+) -> tuple[dict[str, str], ByteStream]:
     plain_data = []
     for key, value in data.items():
         if isinstance(value, (list, tuple)):
@@ -119,14 +148,14 @@ def encode_urlencoded_data(
 
 
 def encode_multipart_data(
-    data: dict, files: RequestFiles, boundary: bytes = None
-) -> Tuple[Dict[str, str], MultipartStream]:
+    data: RequestData, files: RequestFiles, boundary: bytes | None
+) -> tuple[dict[str, str], MultipartStream]:
     multipart = MultipartStream(data=data, files=files, boundary=boundary)
     headers = multipart.get_headers()
     return headers, multipart
 
 
-def encode_text(text: str) -> Tuple[Dict[str, str], ByteStream]:
+def encode_text(text: str) -> tuple[dict[str, str], ByteStream]:
     body = text.encode("utf-8")
     content_length = str(len(body))
     content_type = "text/plain; charset=utf-8"
@@ -134,7 +163,7 @@ def encode_text(text: str) -> Tuple[Dict[str, str], ByteStream]:
     return headers, ByteStream(body)
 
 
-def encode_html(html: str) -> Tuple[Dict[str, str], ByteStream]:
+def encode_html(html: str) -> tuple[dict[str, str], ByteStream]:
     body = html.encode("utf-8")
     content_length = str(len(body))
     content_type = "text/html; charset=utf-8"
@@ -142,7 +171,7 @@ def encode_html(html: str) -> Tuple[Dict[str, str], ByteStream]:
     return headers, ByteStream(body)
 
 
-def encode_json(json: Any) -> Tuple[Dict[str, str], ByteStream]:
+def encode_json(json: Any) -> tuple[dict[str, str], ByteStream]:
     body = json_dumps(json).encode("utf-8")
     content_length = str(len(body))
     content_type = "application/json"
@@ -151,18 +180,18 @@ def encode_json(json: Any) -> Tuple[Dict[str, str], ByteStream]:
 
 
 def encode_request(
-    content: RequestContent = None,
-    data: RequestData = None,
-    files: RequestFiles = None,
-    json: Any = None,
-    boundary: bytes = None,
-) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: Any | None = None,
+    boundary: bytes | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
     """
     Handles encoding the given `content`, `data`, `files`, and `json`,
     returning a two-tuple of (<headers>, <stream>).
     """
-    if data is not None and not isinstance(data, dict):
-        # We prefer to seperate `content=<bytes|str|byte iterator|bytes aiterator>`
+    if data is not None and not isinstance(data, Mapping):
+        # We prefer to separate `content=<bytes|str|byte iterator|bytes aiterator>`
         # for raw request content, and `data=<form data>` for url encoded or
         # multipart form content.
         #
@@ -186,11 +215,11 @@ def encode_request(
 
 
 def encode_response(
-    content: ResponseContent = None,
-    text: str = None,
-    html: str = None,
-    json: Any = None,
-) -> Tuple[Dict[str, str], Union[SyncByteStream, AsyncByteStream]]:
+    content: ResponseContent | None = None,
+    text: str | None = None,
+    html: str | None = None,
+    json: Any | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
     """
     Handles encoding the given `content`, returning a two-tuple of
     (<headers>, <stream>).
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_decoders.py b/addon/globalPlugins/spellcheck/libs/httpx/_decoders.py
index 5081c86..31c72c7 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_decoders.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_decoders.py
@@ -3,6 +3,8 @@
 
 See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
 """
+from __future__ import annotations
+
 import codecs
 import io
 import typing
@@ -14,10 +16,10 @@
 
 class ContentDecoder:
     def decode(self, data: bytes) -> bytes:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
     def flush(self) -> bytes:
-        raise NotImplementedError()  # pragma: nocover
+        raise NotImplementedError()  # pragma: no cover
 
 
 class IdentityDecoder(ContentDecoder):
@@ -57,7 +59,7 @@ def decode(self, data: bytes) -> bytes:
     def flush(self) -> bytes:
         try:
             return self.decompressor.flush()
-        except zlib.error as exc:  # pragma: nocover
+        except zlib.error as exc:  # pragma: no cover
             raise DecodingError(str(exc)) from exc
 
 
@@ -80,7 +82,7 @@ def decode(self, data: bytes) -> bytes:
     def flush(self) -> bytes:
         try:
             return self.decompressor.flush()
-        except zlib.error as exc:  # pragma: nocover
+        except zlib.error as exc:  # pragma: no cover
             raise DecodingError(str(exc)) from exc
 
 
@@ -95,7 +97,7 @@ class BrotliDecoder(ContentDecoder):
     """
 
     def __init__(self) -> None:
-        if brotli is None:  # pragma: nocover
+        if brotli is None:  # pragma: no cover
             raise ImportError(
                 "Using 'BrotliDecoder', but neither of the 'brotlicffi' or 'brotli' "
                 "packages have been installed. "
@@ -104,12 +106,13 @@ def __init__(self) -> None:
 
         self.decompressor = brotli.Decompressor()
         self.seen_data = False
+        self._decompress: typing.Callable[[bytes], bytes]
         if hasattr(self.decompressor, "decompress"):
             # The 'brotlicffi' package.
-            self._decompress = self.decompressor.decompress  # pragma: nocover
+            self._decompress = self.decompressor.decompress  # pragma: no cover
         else:
             # The 'brotli' package.
-            self._decompress = self.decompressor.process  # pragma: nocover
+            self._decompress = self.decompressor.process  # pragma: no cover
 
     def decode(self, data: bytes) -> bytes:
         if not data:
@@ -130,9 +133,9 @@ def flush(self) -> bytes:
                 # As the decompressor decompresses eagerly, this
                 # will never actually emit any data. However, it will potentially throw
                 # errors if a truncated or damaged data stream has been used.
-                self.decompressor.finish()  # pragma: nocover
+                self.decompressor.finish()  # pragma: no cover
             return b""
-        except brotli.error as exc:  # pragma: nocover
+        except brotli.error as exc:  # pragma: no cover
             raise DecodingError(str(exc)) from exc
 
 
@@ -166,13 +169,13 @@ class ByteChunker:
     Handles returning byte content in fixed-size chunks.
     """
 
-    def __init__(self, chunk_size: int = None) -> None:
+    def __init__(self, chunk_size: int | None = None) -> None:
         self._buffer = io.BytesIO()
         self._chunk_size = chunk_size
 
-    def decode(self, content: bytes) -> typing.List[bytes]:
+    def decode(self, content: bytes) -> list[bytes]:
         if self._chunk_size is None:
-            return [content]
+            return [content] if content else []
 
         self._buffer.write(content)
         if self._buffer.tell() >= self._chunk_size:
@@ -193,7 +196,7 @@ def decode(self, content: bytes) -> typing.List[bytes]:
         else:
             return []
 
-    def flush(self) -> typing.List[bytes]:
+    def flush(self) -> list[bytes]:
         value = self._buffer.getvalue()
         self._buffer.seek(0)
         self._buffer.truncate()
@@ -205,13 +208,13 @@ class TextChunker:
     Handles returning text content in fixed-size chunks.
     """
 
-    def __init__(self, chunk_size: int = None) -> None:
+    def __init__(self, chunk_size: int | None = None) -> None:
         self._buffer = io.StringIO()
         self._chunk_size = chunk_size
 
-    def decode(self, content: str) -> typing.List[str]:
+    def decode(self, content: str) -> list[str]:
         if self._chunk_size is None:
-            return [content]
+            return [content] if content else []
 
         self._buffer.write(content)
         if self._buffer.tell() >= self._chunk_size:
@@ -232,7 +235,7 @@ def decode(self, content: str) -> typing.List[str]:
         else:
             return []
 
-    def flush(self) -> typing.List[str]:
+    def flush(self) -> list[str]:
         value = self._buffer.getvalue()
         self._buffer.seek(0)
         self._buffer.truncate()
@@ -244,7 +247,7 @@ class TextDecoder:
     Handles incrementally decoding bytes into text
     """
 
-    def __init__(self, encoding: str = "utf-8"):
+    def __init__(self, encoding: str = "utf-8") -> None:
         self.decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
 
     def decode(self, data: bytes) -> str:
@@ -258,66 +261,59 @@ class LineDecoder:
     """
     Handles incrementally reading lines from text.
 
-    Uses universal line decoding, supporting any of `\n`, `\r`, or `\r\n`
-    as line endings, normalizing to `\n`.
+    Has the same behaviour as the stdllib splitlines,
+    but handling the input iteratively.
     """
 
     def __init__(self) -> None:
-        self.buffer = ""
-
-    def decode(self, text: str) -> typing.List[str]:
-        lines = []
-
-        if text and self.buffer and self.buffer[-1] == "\r":
-            if text.startswith("\n"):
-                # Handle the case where we have an "\r\n" split across
-                # our previous input, and our new chunk.
-                lines.append(self.buffer[:-1] + "\n")
-                self.buffer = ""
-                text = text[1:]
-            else:
-                # Handle the case where we have "\r" at the end of our
-                # previous input.
-                lines.append(self.buffer[:-1] + "\n")
-                self.buffer = ""
-
-        while text:
-            num_chars = len(text)
-            for idx in range(num_chars):
-                char = text[idx]
-                next_char = None if idx + 1 == num_chars else text[idx + 1]
-                if char == "\n":
-                    lines.append(self.buffer + text[: idx + 1])
-                    self.buffer = ""
-                    text = text[idx + 1 :]
-                    break
-                elif char == "\r" and next_char == "\n":
-                    lines.append(self.buffer + text[:idx] + "\n")
-                    self.buffer = ""
-                    text = text[idx + 2 :]
-                    break
-                elif char == "\r" and next_char is not None:
-                    lines.append(self.buffer + text[:idx] + "\n")
-                    self.buffer = ""
-                    text = text[idx + 1 :]
-                    break
-                elif next_char is None:
-                    self.buffer += text
-                    text = ""
-                    break
+        self.buffer: list[str] = []
+        self.trailing_cr: bool = False
+
+    def decode(self, text: str) -> list[str]:
+        # See https://docs.python.org/3/library/stdtypes.html#str.splitlines
+        NEWLINE_CHARS = "\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029"
+
+        # We always push a trailing `\r` into the next decode iteration.
+        if self.trailing_cr:
+            text = "\r" + text
+            self.trailing_cr = False
+        if text.endswith("\r"):
+            self.trailing_cr = True
+            text = text[:-1]
+
+        if not text:
+            # NOTE: the edge case input of empty text doesn't occur in practice,
+            # because other httpx internals filter out this value
+            return []  # pragma: no cover
+
+        trailing_newline = text[-1] in NEWLINE_CHARS
+        lines = text.splitlines()
+
+        if len(lines) == 1 and not trailing_newline:
+            # No new lines, buffer the input and continue.
+            self.buffer.append(lines[0])
+            return []
+
+        if self.buffer:
+            # Include any existing buffer in the first portion of the
+            # splitlines result.
+            lines = ["".join(self.buffer) + lines[0]] + lines[1:]
+            self.buffer = []
+
+        if not trailing_newline:
+            # If the last segment of splitlines is not newline terminated,
+            # then drop it from our output and start a new buffer.
+            self.buffer = [lines.pop()]
 
         return lines
 
-    def flush(self) -> typing.List[str]:
-        if self.buffer.endswith("\r"):
-            # Handle the case where we had a trailing '\r', which could have
-            # been a '\r\n' pair.
-            lines = [self.buffer[:-1] + "\n"]
-        elif self.buffer:
-            lines = [self.buffer]
-        else:
-            lines = []
-        self.buffer = ""
+    def flush(self) -> list[str]:
+        if not self.buffer and not self.trailing_cr:
+            return []
+
+        lines = ["".join(self.buffer)]
+        self.buffer = []
+        self.trailing_cr = False
         return lines
 
 
@@ -330,4 +326,4 @@ def flush(self) -> typing.List[str]:
 
 
 if brotli is None:
-    SUPPORTED_DECODERS.pop("br")  # pragma: nocover
+    SUPPORTED_DECODERS.pop("br")  # pragma: no cover
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_exceptions.py b/addon/globalPlugins/spellcheck/libs/httpx/_exceptions.py
index b6e59aa..1142462 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_exceptions.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_exceptions.py
@@ -21,7 +21,6 @@
       - UnsupportedProtocol
     + DecodingError
     + TooManyRedirects
-    + RequestBodyUnavailable
   x HTTPStatusError
 * InvalidURL
 * CookieConflict
@@ -31,11 +30,13 @@
   x ResponseNotRead
   x RequestNotRead
 """
+from __future__ import annotations
+
 import contextlib
 import typing
 
 if typing.TYPE_CHECKING:
-    from ._models import Request, Response  # pragma: nocover
+    from ._models import Request, Response  # pragma: no cover
 
 
 class HTTPError(Exception):
@@ -58,6 +59,17 @@ class HTTPError(Exception):
 
     def __init__(self, message: str) -> None:
         super().__init__(message)
+        self._request: Request | None = None
+
+    @property
+    def request(self) -> Request:
+        if self._request is None:
+            raise RuntimeError("The .request property has not been set.")
+        return self._request
+
+    @request.setter
+    def request(self, request: Request) -> None:
+        self._request = request
 
 
 class RequestError(HTTPError):
@@ -65,7 +77,7 @@ class RequestError(HTTPError):
     Base class for all exceptions that may occur when issuing a `.request()`.
     """
 
-    def __init__(self, message: str, *, request: "Request" = None) -> None:
+    def __init__(self, message: str, *, request: Request | None = None) -> None:
         super().__init__(message)
         # At the point an exception is raised we won't typically have a request
         # instance to associate it with.
@@ -75,16 +87,6 @@ def __init__(self, message: str, *, request: "Request" = None) -> None:
         # have a `.request` property set on them.
         self._request = request
 
-    @property
-    def request(self) -> "Request":
-        if self._request is None:
-            raise RuntimeError("The .request property has not been set.")
-        return self._request
-
-    @request.setter
-    def request(self, request: "Request") -> None:
-        self._request = request
-
 
 class TransportError(RequestError):
     """
@@ -199,7 +201,7 @@ class RemoteProtocolError(ProtocolError):
     """
     The protocol was violated by the server.
 
-    For exaample, returning malformed HTTP.
+    For example, returning malformed HTTP.
     """
 
 
@@ -228,9 +230,7 @@ class HTTPStatusError(HTTPError):
     May be raised when calling `response.raise_for_status()`
     """
 
-    def __init__(
-        self, message: str, *, request: "Request", response: "Response"
-    ) -> None:
+    def __init__(self, message: str, *, request: Request, response: Response) -> None:
         super().__init__(message)
         self.request = request
         self.response = response
@@ -311,7 +311,10 @@ class ResponseNotRead(StreamError):
     """
 
     def __init__(self) -> None:
-        message = "Attempted to access streaming response content, without having called `read()`."
+        message = (
+            "Attempted to access streaming response content,"
+            " without having called `read()`."
+        )
         super().__init__(message)
 
 
@@ -321,12 +324,17 @@ class RequestNotRead(StreamError):
     """
 
     def __init__(self) -> None:
-        message = "Attempted to access streaming request content, without having called `read()`."
+        message = (
+            "Attempted to access streaming request content,"
+            " without having called `read()`."
+        )
         super().__init__(message)
 
 
 @contextlib.contextmanager
-def request_context(request: "Request" = None) -> typing.Iterator[None]:
+def request_context(
+    request: Request | None = None,
+) -> typing.Iterator[None]:
     """
     A context manager that can be used to attach the given request context
     to any `RequestError` exceptions that are raised within the block.
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_main.py b/addon/globalPlugins/spellcheck/libs/httpx/_main.py
new file mode 100644
index 0000000..72657f8
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_main.py
@@ -0,0 +1,509 @@
+from __future__ import annotations
+
+import functools
+import json
+import sys
+import typing
+
+import click
+import httpcore
+import pygments.lexers
+import pygments.util
+import rich.console
+import rich.markup
+import rich.progress
+import rich.syntax
+import rich.table
+
+from ._client import Client
+from ._exceptions import RequestError
+from ._models import Response
+from ._status_codes import codes
+
+
+def print_help() -> None:
+    console = rich.console.Console()
+
+    console.print("[bold]HTTPX :butterfly:", justify="center")
+    console.print()
+    console.print("A next generation HTTP client.", justify="center")
+    console.print()
+    console.print(
+        "Usage: [bold]httpx[/bold] [cyan]<URL> [OPTIONS][/cyan] ", justify="left"
+    )
+    console.print()
+
+    table = rich.table.Table.grid(padding=1, pad_edge=True)
+    table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
+    table.add_column("Description")
+    table.add_row(
+        "-m, --method [cyan]METHOD",
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.\n"
+        "[Default: GET, or POST if a request body is included]",
+    )
+    table.add_row(
+        "-p, --params [cyan]<NAME VALUE> ...",
+        "Query parameters to include in the request URL.",
+    )
+    table.add_row(
+        "-c, --content [cyan]TEXT", "Byte content to include in the request body."
+    )
+    table.add_row(
+        "-d, --data [cyan]<NAME VALUE> ...", "Form data to include in the request body."
+    )
+    table.add_row(
+        "-f, --files [cyan]<NAME FILENAME> ...",
+        "Form files to include in the request body.",
+    )
+    table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
+    table.add_row(
+        "-h, --headers [cyan]<NAME VALUE> ...",
+        "Include additional HTTP headers in the request.",
+    )
+    table.add_row(
+        "--cookies [cyan]<NAME VALUE> ...", "Cookies to include in the request."
+    )
+    table.add_row(
+        "--auth [cyan]<USER PASS>",
+        "Username and password to include in the request. Specify '-' for the password"
+        " to use a password prompt. Note that using --verbose/-v will expose"
+        " the Authorization header, including the password encoding"
+        " in a trivially reversible format.",
+    )
+
+    table.add_row(
+        "--proxy [cyan]URL",
+        "Send the request via a proxy. Should be the URL giving the proxy address.",
+    )
+
+    table.add_row(
+        "--timeout [cyan]FLOAT",
+        "Timeout value to use for network operations, such as establishing the"
+        " connection, reading some data, etc... [Default: 5.0]",
+    )
+
+    table.add_row("--follow-redirects", "Automatically follow redirects.")
+    table.add_row("--no-verify", "Disable SSL verification.")
+    table.add_row(
+        "--http2", "Send the request using HTTP/2, if the remote server supports it."
+    )
+
+    table.add_row(
+        "--download [cyan]FILE",
+        "Save the response content as a file, rather than displaying it.",
+    )
+
+    table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
+    table.add_row("--help", "Show this message and exit.")
+    console.print(table)
+
+
+def get_lexer_for_response(response: Response) -> str:
+    content_type = response.headers.get("Content-Type")
+    if content_type is not None:
+        mime_type, _, _ = content_type.partition(";")
+        try:
+            return typing.cast(
+                str, pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name
+            )
+        except pygments.util.ClassNotFound:  # pragma: no cover
+            pass
+    return ""  # pragma: no cover
+
+
+def format_request_headers(request: httpcore.Request, http2: bool = False) -> str:
+    version = "HTTP/2" if http2 else "HTTP/1.1"
+    headers = [
+        (name.lower() if http2 else name, value) for name, value in request.headers
+    ]
+    method = request.method.decode("ascii")
+    target = request.url.target.decode("ascii")
+    lines = [f"{method} {target} {version}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def format_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> str:
+    version = http_version.decode("ascii")
+    reason = (
+        codes.get_reason_phrase(status)
+        if reason_phrase is None
+        else reason_phrase.decode("ascii")
+    )
+    lines = [f"{version} {status} {reason}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def print_request_headers(request: httpcore.Request, http2: bool = False) -> None:
+    console = rich.console.Console()
+    http_text = format_request_headers(request, http2=http2)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> None:
+    console = rich.console.Console()
+    http_text = format_response_headers(http_version, status, reason_phrase, headers)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response(response: Response) -> None:
+    console = rich.console.Console()
+    lexer_name = get_lexer_for_response(response)
+    if lexer_name:
+        if lexer_name.lower() == "json":
+            try:
+                data = response.json()
+                text = json.dumps(data, indent=4)
+            except ValueError:  # pragma: no cover
+                text = response.text
+        else:
+            text = response.text
+
+        syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
+        console.print(syntax)
+    else:
+        console.print(f"<{len(response.content)} bytes of binary data>")
+
+
+_PCTRTT = typing.Tuple[typing.Tuple[str, str], ...]
+_PCTRTTT = typing.Tuple[_PCTRTT, ...]
+_PeerCertRetDictType = typing.Dict[str, typing.Union[str, _PCTRTTT, _PCTRTT]]
+
+
+def format_certificate(cert: _PeerCertRetDictType) -> str:  # pragma: no cover
+    lines = []
+    for key, value in cert.items():
+        if isinstance(value, (list, tuple)):
+            lines.append(f"*   {key}:")
+            for item in value:
+                if key in ("subject", "issuer"):
+                    for sub_item in item:
+                        lines.append(f"*     {sub_item[0]}: {sub_item[1]!r}")
+                elif isinstance(item, tuple) and len(item) == 2:
+                    lines.append(f"*     {item[0]}: {item[1]!r}")
+                else:
+                    lines.append(f"*     {item!r}")
+        else:
+            lines.append(f"*   {key}: {value!r}")
+    return "\n".join(lines)
+
+
+def trace(
+    name: str, info: typing.Mapping[str, typing.Any], verbose: bool = False
+) -> None:
+    console = rich.console.Console()
+    if name == "connection.connect_tcp.started" and verbose:
+        host = info["host"]
+        console.print(f"* Connecting to {host!r}")
+    elif name == "connection.connect_tcp.complete" and verbose:
+        stream = info["return_value"]
+        server_addr = stream.get_extra_info("server_addr")
+        console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
+    elif name == "connection.start_tls.complete" and verbose:  # pragma: no cover
+        stream = info["return_value"]
+        ssl_object = stream.get_extra_info("ssl_object")
+        version = ssl_object.version()
+        cipher = ssl_object.cipher()
+        server_cert = ssl_object.getpeercert()
+        alpn = ssl_object.selected_alpn_protocol()
+        console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
+        console.print(f"* Selected ALPN protocol: {alpn!r}")
+        if server_cert:
+            console.print("* Server certificate:")
+            console.print(format_certificate(server_cert))
+    elif name == "http11.send_request_headers.started" and verbose:
+        request = info["request"]
+        print_request_headers(request, http2=False)
+    elif name == "http2.send_request_headers.started" and verbose:  # pragma: no cover
+        request = info["request"]
+        print_request_headers(request, http2=True)
+    elif name == "http11.receive_response_headers.complete":
+        http_version, status, reason_phrase, headers = info["return_value"]
+        print_response_headers(http_version, status, reason_phrase, headers)
+    elif name == "http2.receive_response_headers.complete":  # pragma: no cover
+        status, headers = info["return_value"]
+        http_version = b"HTTP/2"
+        reason_phrase = None
+        print_response_headers(http_version, status, reason_phrase, headers)
+
+
+def download_response(response: Response, download: typing.BinaryIO) -> None:
+    console = rich.console.Console()
+    console.print()
+    content_length = response.headers.get("Content-Length")
+    with rich.progress.Progress(
+        "[progress.description]{task.description}",
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        rich.progress.BarColumn(bar_width=None),
+        rich.progress.DownloadColumn(),
+        rich.progress.TransferSpeedColumn(),
+    ) as progress:
+        description = f"Downloading [bold]{rich.markup.escape(download.name)}"
+        download_task = progress.add_task(
+            description,
+            total=int(content_length or 0),
+            start=content_length is not None,
+        )
+        for chunk in response.iter_bytes():
+            download.write(chunk)
+            progress.update(download_task, completed=response.num_bytes_downloaded)
+
+
+def validate_json(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value is None:
+        return None
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:  # pragma: no cover
+        raise click.BadParameter("Not valid JSON")
+
+
+def validate_auth(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value == (None, None):
+        return None
+
+    username, password = value
+    if password == "-":  # pragma: no cover
+        password = click.prompt("Password", hide_input=True)
+    return (username, password)
+
+
+def handle_help(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> None:
+    if not value or ctx.resilient_parsing:
+        return
+
+    print_help()
+    ctx.exit()
+
+
+@click.command(add_help_option=False)
+@click.argument("url", type=str)
+@click.option(
+    "--method",
+    "-m",
+    "method",
+    type=str,
+    help=(
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD. "
+        "[Default: GET, or POST if a request body is included]"
+    ),
+)
+@click.option(
+    "--params",
+    "-p",
+    "params",
+    type=(str, str),
+    multiple=True,
+    help="Query parameters to include in the request URL.",
+)
+@click.option(
+    "--content",
+    "-c",
+    "content",
+    type=str,
+    help="Byte content to include in the request body.",
+)
+@click.option(
+    "--data",
+    "-d",
+    "data",
+    type=(str, str),
+    multiple=True,
+    help="Form data to include in the request body.",
+)
+@click.option(
+    "--files",
+    "-f",
+    "files",
+    type=(str, click.File(mode="rb")),
+    multiple=True,
+    help="Form files to include in the request body.",
+)
+@click.option(
+    "--json",
+    "-j",
+    "json",
+    type=str,
+    callback=validate_json,
+    help="JSON data to include in the request body.",
+)
+@click.option(
+    "--headers",
+    "-h",
+    "headers",
+    type=(str, str),
+    multiple=True,
+    help="Include additional HTTP headers in the request.",
+)
+@click.option(
+    "--cookies",
+    "cookies",
+    type=(str, str),
+    multiple=True,
+    help="Cookies to include in the request.",
+)
+@click.option(
+    "--auth",
+    "auth",
+    type=(str, str),
+    default=(None, None),
+    callback=validate_auth,
+    help=(
+        "Username and password to include in the request. "
+        "Specify '-' for the password to use a password prompt. "
+        "Note that using --verbose/-v will expose the Authorization header, "
+        "including the password encoding in a trivially reversible format."
+    ),
+)
+@click.option(
+    "--proxy",
+    "proxy",
+    type=str,
+    default=None,
+    help="Send the request via a proxy. Should be the URL giving the proxy address.",
+)
+@click.option(
+    "--timeout",
+    "timeout",
+    type=float,
+    default=5.0,
+    help=(
+        "Timeout value to use for network operations, such as establishing the "
+        "connection, reading some data, etc... [Default: 5.0]"
+    ),
+)
+@click.option(
+    "--follow-redirects",
+    "follow_redirects",
+    is_flag=True,
+    default=False,
+    help="Automatically follow redirects.",
+)
+@click.option(
+    "--no-verify",
+    "verify",
+    is_flag=True,
+    default=True,
+    help="Disable SSL verification.",
+)
+@click.option(
+    "--http2",
+    "http2",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Send the request using HTTP/2, if the remote server supports it.",
+)
+@click.option(
+    "--download",
+    type=click.File("wb"),
+    help="Save the response content as a file, rather than displaying it.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Verbose. Show request as well as response.",
+)
+@click.option(
+    "--help",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=handle_help,
+    help="Show this message and exit.",
+)
+def main(
+    url: str,
+    method: str,
+    params: list[tuple[str, str]],
+    content: str,
+    data: list[tuple[str, str]],
+    files: list[tuple[str, click.File]],
+    json: str,
+    headers: list[tuple[str, str]],
+    cookies: list[tuple[str, str]],
+    auth: tuple[str, str] | None,
+    proxy: str,
+    timeout: float,
+    follow_redirects: bool,
+    verify: bool,
+    http2: bool,
+    download: typing.BinaryIO | None,
+    verbose: bool,
+) -> None:
+    """
+    An HTTP command line client.
+    Sends a request and displays the response.
+    """
+    if not method:
+        method = "POST" if content or data or files or json else "GET"
+
+    try:
+        with Client(
+            proxy=proxy,
+            timeout=timeout,
+            verify=verify,
+            http2=http2,
+        ) as client:
+            with client.stream(
+                method,
+                url,
+                params=list(params),
+                content=content,
+                data=dict(data),
+                files=files,  # type: ignore
+                json=json,
+                headers=headers,
+                cookies=dict(cookies),
+                auth=auth,
+                follow_redirects=follow_redirects,
+                extensions={"trace": functools.partial(trace, verbose=verbose)},
+            ) as response:
+                if download is not None:
+                    download_response(response, download)
+                else:
+                    response.read()
+                    if response.content:
+                        print_response(response)
+
+    except RequestError as exc:
+        console = rich.console.Console()
+        console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
+        sys.exit(1)
+
+    sys.exit(0 if response.is_success else 1)
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_models.py b/addon/globalPlugins/spellcheck/libs/httpx/_models.py
index c86d37d..cd76705 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_models.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_models.py
@@ -1,17 +1,12 @@
-import cgi
+from __future__ import annotations
+
 import datetime
 import email.message
 import json as jsonlib
 import typing
 import urllib.request
-from collections.abc import MutableMapping
+from collections.abc import Mapping
 from http.cookiejar import Cookie, CookieJar
-from urllib.parse import parse_qs, quote, unquote, urlencode
-
-import charset_normalizer
-import idna
-import rfc3986
-import rfc3986.exceptions
 
 from ._content import ByteStream, UnattachedStream, encode_request, encode_response
 from ._decoders import (
@@ -27,812 +22,53 @@
 from ._exceptions import (
     CookieConflict,
     HTTPStatusError,
-    InvalidURL,
     RequestNotRead,
     ResponseNotRead,
     StreamClosed,
     StreamConsumed,
     request_context,
 )
+from ._multipart import get_multipart_boundary_from_content_type
 from ._status_codes import codes
-from ._transports.base import AsyncByteStream, SyncByteStream
 from ._types import (
+    AsyncByteStream,
     CookieTypes,
     HeaderTypes,
-    PrimitiveData,
     QueryParamTypes,
-    RawURL,
     RequestContent,
     RequestData,
+    RequestExtensions,
     RequestFiles,
     ResponseContent,
-    URLTypes,
+    ResponseExtensions,
+    SyncByteStream,
 )
+from ._urls import URL
 from ._utils import (
-    guess_json_utf,
     is_known_encoding,
     normalize_header_key,
     normalize_header_value,
     obfuscate_sensitive_headers,
+    parse_content_type_charset,
     parse_header_links,
-    primitive_value_to_str,
 )
 
 
-class URL:
-    """
-    url = httpx.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
-
-    assert url.scheme == "https"
-    assert url.username == "jo@email.com"
-    assert url.password == "a secret"
-    assert url.userinfo == b"jo%40email.com:a%20secret"
-    assert url.host == "müller.de"
-    assert url.raw_host == b"xn--mller-kva.de"
-    assert url.port == 1234
-    assert url.netloc == b"xn--mller-kva.de:1234"
-    assert url.path == "/pa th"
-    assert url.query == b"?search=ab"
-    assert url.raw_path == b"/pa%20th?search=ab"
-    assert url.fragment == "anchorlink"
-
-    The components of a URL are broken down like this:
-
-       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
-    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
-               [       userinfo        ] [   netloc   ][    raw_path    ]
-
-    Note that:
-
-    * `url.scheme` is normalized to always be lowercased.
-
-    * `url.host` is normalized to always be lowercased. Internationalized domain
-      names are represented in unicode, without IDNA encoding applied. For instance:
-
-      url = httpx.URL("http://中国.icom.museum")
-      assert url.host == "中国.icom.museum"
-      url = httpx.URL("http://xn--fiqs8s.icom.museum")
-      assert url.host == "中国.icom.museum"
-
-    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
-
-      url = httpx.URL("http://中国.icom.museum")
-      assert url.raw_host == b"xn--fiqs8s.icom.museum"
-      url = httpx.URL("http://xn--fiqs8s.icom.museum")
-      assert url.raw_host == b"xn--fiqs8s.icom.museum"
-
-    * `url.port` is either None or an integer. URLs that include the default port for
-      "http", "https", "ws", "wss", and "ftp" schemes have their port normalized to `None`.
-
-      assert httpx.URL("http://example.com") == httpx.URL("http://example.com:80")
-      assert httpx.URL("http://example.com").port is None
-      assert httpx.URL("http://example.com:80").port is None
-
-    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work with
-      `url.username` and `url.password` instead, which handle the URL escaping.
-
-    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
-      This portion is used as the target when constructing HTTP requests. Usually you'll
-      want to work with `url.path` instead.
-
-    * `url.query` is raw bytes, without URL escaping. A URL query string portion can only
-      be properly URL escaped when decoding the parameter names and values themselves.
-    """
-
-    def __init__(
-        self, url: typing.Union["URL", str, RawURL] = "", **kwargs: typing.Any
-    ) -> None:
-        if isinstance(url, (str, tuple)):
-            if isinstance(url, tuple):
-                raw_scheme, raw_host, port, raw_path = url
-                scheme = raw_scheme.decode("ascii")
-                host = raw_host.decode("ascii")
-                if host and ":" in host and host[0] != "[":
-                    # it's an IPv6 address, so it should be enclosed in "[" and "]"
-                    # ref: https://tools.ietf.org/html/rfc2732#section-2
-                    # ref: https://tools.ietf.org/html/rfc3986#section-3.2.2
-                    host = f"[{host}]"
-                port_str = "" if port is None else f":{port}"
-                path = raw_path.decode("ascii")
-                url = f"{scheme}://{host}{port_str}{path}"
-
-            try:
-                self._uri_reference = rfc3986.iri_reference(url).encode()
-            except rfc3986.exceptions.InvalidAuthority as exc:
-                raise InvalidURL(message=str(exc)) from None
-
-            if self.is_absolute_url:
-                # We don't want to normalize relative URLs, since doing so
-                # removes any leading `../` portion.
-                self._uri_reference = self._uri_reference.normalize()
-        elif isinstance(url, URL):
-            self._uri_reference = url._uri_reference
-        else:
-            raise TypeError(
-                f"Invalid type for url.  Expected str or httpx.URL, got {type(url)}: {url!r}"
-            )
-
-        # Perform port normalization, following the WHATWG spec for default ports.
-        #
-        # See:
-        # * https://tools.ietf.org/html/rfc3986#section-3.2.3
-        # * https://url.spec.whatwg.org/#url-miscellaneous
-        # * https://url.spec.whatwg.org/#scheme-state
-        default_port = {
-            "ftp": ":21",
-            "http": ":80",
-            "https": ":443",
-            "ws": ":80",
-            "wss": ":443",
-        }.get(self._uri_reference.scheme, "")
-        authority = self._uri_reference.authority or ""
-        if default_port and authority.endswith(default_port):
-            authority = authority[: -len(default_port)]
-            self._uri_reference = self._uri_reference.copy_with(authority=authority)
-
-        if kwargs:
-            self._uri_reference = self.copy_with(**kwargs)._uri_reference
-
-    @property
-    def scheme(self) -> str:
-        """
-        The URL scheme, such as "http", "https".
-        Always normalised to lowercase.
-        """
-        return self._uri_reference.scheme or ""
-
-    @property
-    def raw_scheme(self) -> bytes:
-        """
-        The raw bytes representation of the URL scheme, such as b"http", b"https".
-        Always normalised to lowercase.
-        """
-        return self.scheme.encode("ascii")
-
-    @property
-    def userinfo(self) -> bytes:
-        """
-        The URL userinfo as a raw bytestring.
-        For example: b"jo%40email.com:a%20secret".
-        """
-        userinfo = self._uri_reference.userinfo or ""
-        return userinfo.encode("ascii")
-
-    @property
-    def username(self) -> str:
-        """
-        The URL username as a string, with URL decoding applied.
-        For example: "jo@email.com"
-        """
-        userinfo = self._uri_reference.userinfo or ""
-        return unquote(userinfo.partition(":")[0])
-
-    @property
-    def password(self) -> str:
-        """
-        The URL password as a string, with URL decoding applied.
-        For example: "a secret"
-        """
-        userinfo = self._uri_reference.userinfo or ""
-        return unquote(userinfo.partition(":")[2])
-
-    @property
-    def host(self) -> str:
-        """
-        The URL host as a string.
-        Always normalized to lowercase, with IDNA hosts decoded into unicode.
-
-        Examples:
-
-        url = httpx.URL("http://www.EXAMPLE.org")
-        assert url.host == "www.example.org"
-
-        url = httpx.URL("http://中国.icom.museum")
-        assert url.host == "中国.icom.museum"
-
-        url = httpx.URL("http://xn--fiqs8s.icom.museum")
-        assert url.host == "中国.icom.museum"
-
-        url = httpx.URL("https://[::ffff:192.168.0.1]")
-        assert url.host == "::ffff:192.168.0.1"
-        """
-        host: str = self._uri_reference.host or ""
-
-        if host and ":" in host and host[0] == "[":
-            # it's an IPv6 address
-            host = host.lstrip("[").rstrip("]")
-
-        if host.startswith("xn--"):
-            host = idna.decode(host)
-
-        return host
-
-    @property
-    def raw_host(self) -> bytes:
-        """
-        The raw bytes representation of the URL host.
-        Always normalized to lowercase, and IDNA encoded.
-
-        Examples:
-
-        url = httpx.URL("http://www.EXAMPLE.org")
-        assert url.raw_host == b"www.example.org"
-
-        url = httpx.URL("http://中国.icom.museum")
-        assert url.raw_host == b"xn--fiqs8s.icom.museum"
-
-        url = httpx.URL("http://xn--fiqs8s.icom.museum")
-        assert url.raw_host == b"xn--fiqs8s.icom.museum"
-
-        url = httpx.URL("https://[::ffff:192.168.0.1]")
-        assert url.raw_host == b"::ffff:192.168.0.1"
-        """
-        host: str = self._uri_reference.host or ""
-
-        if host and ":" in host and host[0] == "[":
-            # it's an IPv6 address
-            host = host.lstrip("[").rstrip("]")
-
-        return host.encode("ascii")
-
-    @property
-    def port(self) -> typing.Optional[int]:
-        """
-        The URL port as an integer.
-
-        Note that the URL class performs port normalization as per the WHATWG spec.
-        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
-        treated as `None`.
-
-        For example:
-
-        assert httpx.URL("http://www.example.com") == httpx.URL("http://www.example.com:80")
-        assert httpx.URL("http://www.example.com:80").port is None
-        """
-        port = self._uri_reference.port
-        return int(port) if port else None
-
-    @property
-    def netloc(self) -> bytes:
-        """
-        Either `<host>` or `<host>:<port>` as bytes.
-        Always normalized to lowercase, and IDNA encoded.
-
-        This property may be used for generating the value of a request
-        "Host" header.
-        """
-        host = self._uri_reference.host or ""
-        port = self._uri_reference.port
-        netloc = host.encode("ascii")
-        if port:
-            netloc = netloc + b":" + port.encode("ascii")
-        return netloc
-
-    @property
-    def path(self) -> str:
-        """
-        The URL path as a string. Excluding the query string, and URL decoded.
-
-        For example:
-
-        url = httpx.URL("https://example.com/pa%20th")
-        assert url.path == "/pa th"
-        """
-        path = self._uri_reference.path or "/"
-        return unquote(path)
-
-    @property
-    def query(self) -> bytes:
-        """
-        The URL query string, as raw bytes, excluding the leading b"?".
-
-        This is neccessarily a bytewise interface, because we cannot
-        perform URL decoding of this representation until we've parsed
-        the keys and values into a QueryParams instance.
-
-        For example:
-
-        url = httpx.URL("https://example.com/?filter=some%20search%20terms")
-        assert url.query == b"filter=some%20search%20terms"
-        """
-        query = self._uri_reference.query or ""
-        return query.encode("ascii")
-
-    @property
-    def params(self) -> "QueryParams":
-        """
-        The URL query parameters, neatly parsed and packaged into an immutable
-        multidict representation.
-        """
-        return QueryParams(self._uri_reference.query)
-
-    @property
-    def raw_path(self) -> bytes:
-        """
-        The complete URL path and query string as raw bytes.
-        Used as the target when constructing HTTP requests.
-
-        For example:
-
-        GET /users?search=some%20text HTTP/1.1
-        Host: www.example.org
-        Connection: close
-        """
-        path = self._uri_reference.path or "/"
-        if self._uri_reference.query is not None:
-            path += "?" + self._uri_reference.query
-        return path.encode("ascii")
-
-    @property
-    def fragment(self) -> str:
-        """
-        The URL fragments, as used in HTML anchors.
-        As a string, without the leading '#'.
-        """
-        return unquote(self._uri_reference.fragment or "")
-
-    @property
-    def raw(self) -> RawURL:
-        """
-        The URL in the raw representation used by the low level
-        transport API. See `BaseTransport.handle_request`.
-
-        Provides the (scheme, host, port, target) for the outgoing request.
-        """
-        return (
-            self.raw_scheme,
-            self.raw_host,
-            self.port,
-            self.raw_path,
-        )
-
-    @property
-    def is_absolute_url(self) -> bool:
-        """
-        Return `True` for absolute URLs such as 'http://example.com/path',
-        and `False` for relative URLs such as '/path'.
-        """
-        # We don't use `.is_absolute` from `rfc3986` because it treats
-        # URLs with a fragment portion as not absolute.
-        # What we actually care about is if the URL provides
-        # a scheme and hostname to which connections should be made.
-        return bool(self._uri_reference.scheme and self._uri_reference.host)
-
-    @property
-    def is_relative_url(self) -> bool:
-        """
-        Return `False` for absolute URLs such as 'http://example.com/path',
-        and `True` for relative URLs such as '/path'.
-        """
-        return not self.is_absolute_url
-
-    def copy_with(self, **kwargs: typing.Any) -> "URL":
-        """
-        Copy this URL, returning a new URL with some components altered.
-        Accepts the same set of parameters as the components that are made
-        available via properties on the `URL` class.
-
-        For example:
-
-        url = httpx.URL("https://www.example.com").copy_with(username="jo@gmail.com", password="a secret")
-        assert url == "https://jo%40email.com:a%20secret@www.example.com"
-        """
-        allowed = {
-            "scheme": str,
-            "username": str,
-            "password": str,
-            "userinfo": bytes,
-            "host": str,
-            "port": int,
-            "netloc": bytes,
-            "path": str,
-            "query": bytes,
-            "raw_path": bytes,
-            "fragment": str,
-            "params": object,
-        }
-
-        # Step 1
-        # ======
-        #
-        # Perform type checking for all supported keyword arguments.
-        for key, value in kwargs.items():
-            if key not in allowed:
-                message = f"{key!r} is an invalid keyword argument for copy_with()"
-                raise TypeError(message)
-            if value is not None and not isinstance(value, allowed[key]):
-                expected = allowed[key].__name__
-                seen = type(value).__name__
-                message = f"Argument {key!r} must be {expected} but got {seen}"
-                raise TypeError(message)
-
-        # Step 2
-        # ======
-        #
-        # Consolidate "username", "password", "userinfo", "host", "port" and "netloc"
-        # into a single "authority" keyword, for `rfc3986`.
-        if "username" in kwargs or "password" in kwargs:
-            # Consolidate "username" and "password" into "userinfo".
-            username = quote(kwargs.pop("username", self.username) or "")
-            password = quote(kwargs.pop("password", self.password) or "")
-            userinfo = f"{username}:{password}" if password else username
-            kwargs["userinfo"] = userinfo.encode("ascii")
-
-        if "host" in kwargs or "port" in kwargs:
-            # Consolidate "host" and "port" into "netloc".
-            host = kwargs.pop("host", self.host) or ""
-            port = kwargs.pop("port", self.port)
-
-            if host and ":" in host and host[0] != "[":
-                # IPv6 addresses need to be escaped within sqaure brackets.
-                host = f"[{host}]"
-
-            kwargs["netloc"] = (
-                f"{host}:{port}".encode("ascii")
-                if port is not None
-                else host.encode("ascii")
-            )
-
-        if "userinfo" in kwargs or "netloc" in kwargs:
-            # Consolidate "userinfo" and "netloc" into authority.
-            userinfo = (kwargs.pop("userinfo", self.userinfo) or b"").decode("ascii")
-            netloc = (kwargs.pop("netloc", self.netloc) or b"").decode("ascii")
-            authority = f"{userinfo}@{netloc}" if userinfo else netloc
-            kwargs["authority"] = authority
-
-        # Step 3
-        # ======
-        #
-        # Wrangle any "path", "query", "raw_path" and "params" keywords into
-        # "query" and "path" keywords for `rfc3986`.
-        if "raw_path" in kwargs:
-            # If "raw_path" is included, then split it into "path" and "query" components.
-            raw_path = kwargs.pop("raw_path") or b""
-            path, has_query, query = raw_path.decode("ascii").partition("?")
-            kwargs["path"] = path
-            kwargs["query"] = query if has_query else None
-
-        else:
-            if kwargs.get("path") is not None:
-                # Ensure `kwargs["path"] = <url quoted str>` for `rfc3986`.
-                kwargs["path"] = quote(kwargs["path"])
-
-            if kwargs.get("query") is not None:
-                # Ensure `kwargs["query"] = <str>` for `rfc3986`.
-                #
-                # Note that `.copy_with(query=None)` and `.copy_with(query=b"")`
-                # are subtly different. The `None` style will not include an empty
-                # trailing "?" character.
-                kwargs["query"] = kwargs["query"].decode("ascii")
-
-            if "params" in kwargs:
-                # Replace any "params" keyword with the raw "query" instead.
-                #
-                # Ensure that empty params use `kwargs["query"] = None` rather
-                # than `kwargs["query"] = ""`, so that generated URLs do not
-                # include an empty trailing "?".
-                params = kwargs.pop("params")
-                kwargs["query"] = None if not params else str(QueryParams(params))
-
-        # Step 4
-        # ======
-        #
-        # Ensure any fragment component is quoted.
-        if kwargs.get("fragment") is not None:
-            kwargs["fragment"] = quote(kwargs["fragment"])
-
-        # Step 5
-        # ======
-        #
-        # At this point kwargs may include keys for "scheme", "authority", "path",
-        # "query" and "fragment". Together these constitute the entire URL.
-        #
-        # See https://tools.ietf.org/html/rfc3986#section-3
-        #
-        #  foo://example.com:8042/over/there?name=ferret#nose
-        #  \_/   \______________/\_________/ \_________/ \__/
-        #   |           |            |            |        |
-        # scheme     authority       path        query   fragment
-        return URL(self._uri_reference.copy_with(**kwargs).unsplit())
-
-    def copy_set_param(self, key: str, value: typing.Any = None) -> "URL":
-        return self.copy_with(params=self.params.set(key, value))
-
-    def copy_add_param(self, key: str, value: typing.Any = None) -> "URL":
-        return self.copy_with(params=self.params.add(key, value))
-
-    def copy_remove_param(self, key: str) -> "URL":
-        return self.copy_with(params=self.params.remove(key))
-
-    def copy_merge_params(self, params: QueryParamTypes) -> "URL":
-        return self.copy_with(params=self.params.merge(params))
-
-    def join(self, url: URLTypes) -> "URL":
-        """
-        Return an absolute URL, using this URL as the base.
-
-        Eg.
-
-        url = httpx.URL("https://www.example.com/test")
-        url = url.join("/new/path")
-        assert url == "https://www.example.com/new/path"
-        """
-        if self.is_relative_url:
-            # Workaround to handle relative URLs, which otherwise raise
-            # rfc3986.exceptions.ResolutionError when used as an argument
-            # in `.resolve_with`.
-            return (
-                self.copy_with(scheme="http", host="example.com")
-                .join(url)
-                .copy_with(scheme=None, host=None)
-            )
-
-        # We drop any fragment portion, because RFC 3986 strictly
-        # treats URLs with a fragment portion as not being absolute URLs.
-        base_uri = self._uri_reference.copy_with(fragment=None)
-        relative_url = URL(url)
-        return URL(relative_url._uri_reference.resolve_with(base_uri).unsplit())
-
-    def __hash__(self) -> int:
-        return hash(str(self))
-
-    def __eq__(self, other: typing.Any) -> bool:
-        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
-
-    def __str__(self) -> str:
-        return self._uri_reference.unsplit()
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        url_str = str(self)
-        if self._uri_reference.userinfo:
-            # Mask any password component in the URL representation, to lower the
-            # risk of unintended leakage, such as in debug information and logging.
-            username = quote(self.username)
-            url_str = (
-                rfc3986.urlparse(url_str)
-                .copy_with(userinfo=f"{username}:[secure]")
-                .unsplit()
-            )
-        return f"{class_name}({url_str!r})"
-
-
-class QueryParams(typing.Mapping[str, str]):
-    """
-    URL query parameters, as a multi-dict.
-    """
-
-    def __init__(self, *args: QueryParamTypes, **kwargs: typing.Any) -> None:
-        assert len(args) < 2, "Too many arguments."
-        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
-
-        value = args[0] if args else kwargs
-
-        items: typing.Sequence[typing.Tuple[str, PrimitiveData]]
-        if value is None or isinstance(value, (str, bytes)):
-            value = value.decode("ascii") if isinstance(value, bytes) else value
-            self._dict = parse_qs(value)
-        elif isinstance(value, QueryParams):
-            self._dict = {k: list(v) for k, v in value._dict.items()}
-        else:
-            dict_value: typing.Dict[typing.Any, typing.List[typing.Any]] = {}
-            if isinstance(value, (list, tuple)):
-                # Convert list inputs like:
-                #     [("a", "123"), ("a", "456"), ("b", "789")]
-                # To a dict representation, like:
-                #     {"a": ["123", "456"], "b": ["789"]}
-                for item in value:
-                    dict_value.setdefault(item[0], []).append(item[1])
-            else:
-                # Convert dict inputs like:
-                #    {"a": "123", "b": ["456", "789"]}
-                # To dict inputs where values are always lists, like:
-                #    {"a": ["123"], "b": ["456", "789"]}
-                dict_value = {
-                    k: list(v) if isinstance(v, (list, tuple)) else [v]
-                    for k, v in value.items()
-                }
-
-            # Ensure that keys and values are neatly coerced to strings.
-            # We coerce values `True` and `False` to JSON-like "true" and "false"
-            # representations, and coerce `None` values to the empty string.
-            self._dict = {
-                str(k): [primitive_value_to_str(item) for item in v]
-                for k, v in dict_value.items()
-            }
-
-    def keys(self) -> typing.KeysView:
-        """
-        Return all the keys in the query params.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert list(q.keys()) == ["a", "b"]
-        """
-        return self._dict.keys()
-
-    def values(self) -> typing.ValuesView:
-        """
-        Return all the values in the query params. If a key occurs more than once
-        only the first item for that key is returned.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert list(q.values()) == ["123", "789"]
-        """
-        return {k: v[0] for k, v in self._dict.items()}.values()
-
-    def items(self) -> typing.ItemsView:
-        """
-        Return all items in the query params. If a key occurs more than once
-        only the first item for that key is returned.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert list(q.items()) == [("a", "123"), ("b", "789")]
-        """
-        return {k: v[0] for k, v in self._dict.items()}.items()
-
-    def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
-        """
-        Return all items in the query params. Allow duplicate keys to occur.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
-        """
-        multi_items: typing.List[typing.Tuple[str, str]] = []
-        for k, v in self._dict.items():
-            multi_items.extend([(k, i) for i in v])
-        return multi_items
-
-    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
-        """
-        Get a value from the query param for a given key. If the key occurs
-        more than once, then only the first value is returned.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert q.get("a") == "123"
-        """
-        if key in self._dict:
-            return self._dict[str(key)][0]
-        return default
-
-    def get_list(self, key: str) -> typing.List[str]:
-        """
-        Get all values from the query param for a given key.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123&a=456&b=789")
-        assert q.get_list("a") == ["123", "456"]
-        """
-        return list(self._dict.get(str(key), []))
-
-    def set(self, key: str, value: typing.Any = None) -> "QueryParams":
-        """
-        Return a new QueryParams instance, setting the value of a key.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123")
-        q = q.set("a", "456")
-        assert q == httpx.QueryParams("a=456")
-        """
-        q = QueryParams()
-        q._dict = dict(self._dict)
-        q._dict[str(key)] = [primitive_value_to_str(value)]
-        return q
-
-    def add(self, key: str, value: typing.Any = None) -> "QueryParams":
-        """
-        Return a new QueryParams instance, setting or appending the value of a key.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123")
-        q = q.add("a", "456")
-        assert q == httpx.QueryParams("a=123&a=456")
-        """
-        q = QueryParams()
-        q._dict = dict(self._dict)
-        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
-        return q
-
-    def remove(self, key: str) -> "QueryParams":
-        """
-        Return a new QueryParams instance, removing the value of a key.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123")
-        q = q.remove("a")
-        assert q == httpx.QueryParams("")
-        """
-        q = QueryParams()
-        q._dict = dict(self._dict)
-        q._dict.pop(str(key), None)
-        return q
-
-    def merge(self, params: QueryParamTypes = None) -> "QueryParams":
-        """
-        Return a new QueryParams instance, updated with.
-
-        Usage:
-
-        q = httpx.QueryParams("a=123")
-        q = q.merge({"b": "456"})
-        assert q == httpx.QueryParams("a=123&b=456")
-
-        q = httpx.QueryParams("a=123")
-        q = q.merge({"a": "456", "b": "789"})
-        assert q == httpx.QueryParams("a=456&b=789")
-        """
-        q = QueryParams(params)
-        q._dict = {**self._dict, **q._dict}
-        return q
-
-    def __getitem__(self, key: typing.Any) -> str:
-        return self._dict[key][0]
-
-    def __contains__(self, key: typing.Any) -> bool:
-        return key in self._dict
-
-    def __iter__(self) -> typing.Iterator[typing.Any]:
-        return iter(self.keys())
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def __bool__(self) -> bool:
-        return bool(self._dict)
-
-    def __hash__(self) -> int:
-        return hash(str(self))
-
-    def __eq__(self, other: typing.Any) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
-        return sorted(self.multi_items()) == sorted(other.multi_items())
-
-    def __str__(self) -> str:
-        return urlencode(self.multi_items())
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        query_string = str(self)
-        return f"{class_name}({query_string!r})"
-
-    def update(self, params: QueryParamTypes = None) -> None:
-        raise RuntimeError(
-            "QueryParams are immutable since 0.18.0. "
-            "Use `q = q.merge(...)` to create an updated copy."
-        )
-
-    def __setitem__(self, key: str, value: str) -> None:
-        raise RuntimeError(
-            "QueryParams are immutable since 0.18.0. "
-            "Use `q = q.set(key, value)` to create an updated copy."
-        )
-
-
 class Headers(typing.MutableMapping[str, str]):
     """
     HTTP headers, as a case-insensitive multi-dict.
     """
 
-    def __init__(self, headers: HeaderTypes = None, encoding: str = None) -> None:
+    def __init__(
+        self,
+        headers: HeaderTypes | None = None,
+        encoding: str | None = None,
+    ) -> None:
         if headers is None:
             self._list = []  # type: typing.List[typing.Tuple[bytes, bytes, bytes]]
         elif isinstance(headers, Headers):
             self._list = list(headers._list)
-        elif isinstance(headers, dict):
+        elif isinstance(headers, Mapping):
             self._list = [
                 (
                     normalize_header_key(k, lower=False, encoding=encoding),
@@ -883,7 +119,7 @@ def encoding(self, value: str) -> None:
         self._encoding = value
 
     @property
-    def raw(self) -> typing.List[typing.Tuple[bytes, bytes]]:
+    def raw(self) -> list[tuple[bytes, bytes]]:
         """
         Returns a list of the raw header items, as byte pairs.
         """
@@ -893,7 +129,7 @@ def keys(self) -> typing.KeysView[str]:
         return {key.decode(self.encoding): None for _, key, value in self._list}.keys()
 
     def values(self) -> typing.ValuesView[str]:
-        values_dict: typing.Dict[str, str] = {}
+        values_dict: dict[str, str] = {}
         for _, key, value in self._list:
             str_key = key.decode(self.encoding)
             str_value = value.decode(self.encoding)
@@ -906,9 +142,9 @@ def values(self) -> typing.ValuesView[str]:
     def items(self) -> typing.ItemsView[str, str]:
         """
         Return `(key, value)` items of headers. Concatenate headers
-        into a single comma seperated value when a key occurs multiple times.
+        into a single comma separated value when a key occurs multiple times.
         """
-        values_dict: typing.Dict[str, str] = {}
+        values_dict: dict[str, str] = {}
         for _, key, value in self._list:
             str_key = key.decode(self.encoding)
             str_value = value.decode(self.encoding)
@@ -918,11 +154,11 @@ def items(self) -> typing.ItemsView[str, str]:
                 values_dict[str_key] = str_value
         return values_dict.items()
 
-    def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
+    def multi_items(self) -> list[tuple[str, str]]:
         """
         Return a list of `(key, value)` pairs of headers. Allow multiple
-        occurences of the same key without concatenating into a single
-        comma seperated value.
+        occurrences of the same key without concatenating into a single
+        comma separated value.
         """
         return [
             (key.decode(self.encoding), value.decode(self.encoding))
@@ -931,7 +167,7 @@ def multi_items(self) -> typing.List[typing.Tuple[str, str]]:
 
     def get(self, key: str, default: typing.Any = None) -> typing.Any:
         """
-        Return a header value. If multiple occurences of the header occur
+        Return a header value. If multiple occurrences of the header occur
         then concatenate them together with commas.
         """
         try:
@@ -939,10 +175,10 @@ def get(self, key: str, default: typing.Any = None) -> typing.Any:
         except KeyError:
             return default
 
-    def get_list(self, key: str, split_commas: bool = False) -> typing.List[str]:
+    def get_list(self, key: str, split_commas: bool = False) -> list[str]:
         """
         Return a list of all header values for a given key.
-        If `split_commas=True` is passed, then any comma seperated header
+        If `split_commas=True` is passed, then any comma separated header
         values are split into multiple return strings.
         """
         get_header_key = key.lower().encode(self.encoding)
@@ -961,12 +197,14 @@ def get_list(self, key: str, split_commas: bool = False) -> typing.List[str]:
             split_values.extend([item.strip() for item in value.split(",")])
         return split_values
 
-    def update(self, headers: HeaderTypes = None) -> None:  # type: ignore
+    def update(self, headers: HeaderTypes | None = None) -> None:  # type: ignore
         headers = Headers(headers)
-        for key, value in headers.raw:
-            self[key.decode(headers.encoding)] = value.decode(headers.encoding)
+        for key in headers.keys():
+            if key in self:
+                self.pop(key)
+        self._list.extend(headers._list)
 
-    def copy(self) -> "Headers":
+    def copy(self) -> Headers:
         return Headers(self, encoding=self.encoding)
 
     def __getitem__(self, key: str) -> str:
@@ -1070,31 +308,46 @@ def __repr__(self) -> str:
 class Request:
     def __init__(
         self,
-        method: typing.Union[str, bytes],
-        url: typing.Union["URL", str, RawURL],
+        method: str | bytes,
+        url: URL | str,
         *,
-        params: QueryParamTypes = None,
-        headers: HeaderTypes = None,
-        cookies: CookieTypes = None,
-        content: RequestContent = None,
-        data: RequestData = None,
-        files: RequestFiles = None,
-        json: typing.Any = None,
-        stream: typing.Union[SyncByteStream, AsyncByteStream] = None,
-    ):
-        if isinstance(method, bytes):
-            self.method = method.decode("ascii").upper()
-        else:
-            self.method = method.upper()
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        extensions: RequestExtensions | None = None,
+    ) -> None:
+        self.method = (
+            method.decode("ascii").upper()
+            if isinstance(method, bytes)
+            else method.upper()
+        )
         self.url = URL(url)
         if params is not None:
             self.url = self.url.copy_merge_params(params=params)
         self.headers = Headers(headers)
+        self.extensions = {} if extensions is None else extensions
+
         if cookies:
             Cookies(cookies).set_cookie_header(self)
 
         if stream is None:
-            headers, stream = encode_request(content, data, files, json)
+            content_type: str | None = self.headers.get("content-type")
+            headers, stream = encode_request(
+                content=content,
+                data=data,
+                files=files,
+                json=json,
+                boundary=get_multipart_boundary_from_content_type(
+                    content_type=content_type.encode(self.headers.encoding)
+                    if content_type
+                    else None
+                ),
+            )
             self._prepare(headers)
             self.stream = stream
             # Load the request body, except for streaming content.
@@ -1107,7 +360,8 @@ def __init__(
             # Using `content=...` implies automatically populated `Host` and content
             # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
             #
-            # Using `stream=...` will not automatically include *any* auto-populated headers.
+            # Using `stream=...` will not automatically include *any*
+            # auto-populated headers.
             #
             # As an end-user you don't really need `stream=...`. It's only
             # useful when:
@@ -1116,14 +370,14 @@ def __init__(
             # * Creating request instances on the *server-side* of the transport API.
             self.stream = stream
 
-    def _prepare(self, default_headers: typing.Dict[str, str]) -> None:
+    def _prepare(self, default_headers: dict[str, str]) -> None:
         for key, value in default_headers.items():
             # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
             if key.lower() == "transfer-encoding" and "Content-Length" in self.headers:
                 continue
             self.headers.setdefault(key, value)
 
-        auto_headers: typing.List[typing.Tuple[bytes, bytes]] = []
+        auto_headers: list[tuple[bytes, bytes]] = []
 
         has_host = "Host" in self.headers
         has_content_length = (
@@ -1176,16 +430,17 @@ def __repr__(self) -> str:
         url = str(self.url)
         return f"<{class_name}({self.method!r}, {url!r})>"
 
-    def __getstate__(self) -> typing.Dict[str, typing.Any]:
+    def __getstate__(self) -> dict[str, typing.Any]:
         return {
             name: value
             for name, value in self.__dict__.items()
-            if name not in ["stream"]
+            if name not in ["extensions", "stream"]
         }
 
-    def __setstate__(self, state: typing.Dict[str, typing.Any]) -> None:
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
         for name, value in state.items():
             setattr(self, name, value)
+        self.extensions = {}
         self.stream = UnattachedStream()
 
 
@@ -1194,31 +449,34 @@ def __init__(
         self,
         status_code: int,
         *,
-        headers: HeaderTypes = None,
-        content: ResponseContent = None,
-        text: str = None,
-        html: str = None,
+        headers: HeaderTypes | None = None,
+        content: ResponseContent | None = None,
+        text: str | None = None,
+        html: str | None = None,
         json: typing.Any = None,
-        stream: typing.Union[SyncByteStream, AsyncByteStream] = None,
-        request: Request = None,
-        extensions: dict = None,
-        history: typing.List["Response"] = None,
-    ):
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        request: Request | None = None,
+        extensions: ResponseExtensions | None = None,
+        history: list[Response] | None = None,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+    ) -> None:
         self.status_code = status_code
         self.headers = Headers(headers)
 
-        self._request: typing.Optional[Request] = request
+        self._request: Request | None = request
 
-        # When allow_redirects=False and a redirect is received,
+        # When follow_redirects=False and a redirect is received,
         # the client will set `response.next_request`.
-        self.next_request: typing.Optional[Request] = None
+        self.next_request: Request | None = None
 
-        self.extensions = {} if extensions is None else extensions
+        self.extensions: ResponseExtensions = {} if extensions is None else extensions
         self.history = [] if history is None else list(history)
 
         self.is_closed = False
         self.is_stream_consumed = False
 
+        self.default_encoding = default_encoding
+
         if stream is None:
             headers, stream = encode_response(content, text, html, json)
             self._prepare(headers)
@@ -1242,7 +500,7 @@ def __init__(
 
         self._num_bytes_downloaded = 0
 
-    def _prepare(self, default_headers: typing.Dict[str, str]) -> None:
+    def _prepare(self, default_headers: dict[str, str]) -> None:
         for key, value in default_headers.items():
             # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
             if key.lower() == "transfer-encoding" and "content-length" in self.headers:
@@ -1284,19 +542,23 @@ def request(self, value: Request) -> None:
     @property
     def http_version(self) -> str:
         try:
-            return self.extensions["http_version"].decode("ascii", errors="ignore")
+            http_version: bytes = self.extensions["http_version"]
         except KeyError:
             return "HTTP/1.1"
+        else:
+            return http_version.decode("ascii", errors="ignore")
 
     @property
     def reason_phrase(self) -> str:
         try:
-            return self.extensions["reason_phrase"].decode("ascii", errors="ignore")
+            reason_phrase: bytes = self.extensions["reason_phrase"]
         except KeyError:
             return codes.get_reason_phrase(self.status_code)
+        else:
+            return reason_phrase.decode("ascii", errors="ignore")
 
     @property
-    def url(self) -> typing.Optional[URL]:
+    def url(self) -> URL:
         """
         Returns the URL for which the request was made.
         """
@@ -1320,29 +582,43 @@ def text(self) -> str:
         return self._text
 
     @property
-    def encoding(self) -> typing.Optional[str]:
+    def encoding(self) -> str | None:
         """
         Return an encoding to use for decoding the byte content into text.
         The priority for determining this is given by...
 
         * `.encoding = <>` has been set explicitly.
         * The encoding as specified by the charset parameter in the Content-Type header.
-        * The encoding as determined by `charset_normalizer`.
-        * UTF-8.
+        * The encoding as determined by `default_encoding`, which may either be
+          a string like "utf-8" indicating the encoding to use, or may be a callable
+          which enables charset autodetection.
         """
         if not hasattr(self, "_encoding"):
             encoding = self.charset_encoding
             if encoding is None or not is_known_encoding(encoding):
-                encoding = self.apparent_encoding
-            self._encoding = encoding
+                if isinstance(self.default_encoding, str):
+                    encoding = self.default_encoding
+                elif hasattr(self, "_content"):
+                    encoding = self.default_encoding(self._content)
+            self._encoding = encoding or "utf-8"
         return self._encoding
 
     @encoding.setter
     def encoding(self, value: str) -> None:
+        """
+        Set the encoding to use for decoding the byte content into text.
+
+        If the `text` attribute has been accessed, attempting to set the
+        encoding will throw a ValueError.
+        """
+        if hasattr(self, "_text"):
+            raise ValueError(
+                "Setting encoding after `text` has been accessed is not allowed."
+            )
         self._encoding = value
 
     @property
-    def charset_encoding(self) -> typing.Optional[str]:
+    def charset_encoding(self) -> str | None:
         """
         Return the encoding, as specified by the Content-Type header.
         """
@@ -1350,24 +626,7 @@ def charset_encoding(self) -> typing.Optional[str]:
         if content_type is None:
             return None
 
-        _, params = cgi.parse_header(content_type)
-        if "charset" not in params:
-            return None
-
-        return params["charset"].strip("'\"")
-
-    @property
-    def apparent_encoding(self) -> typing.Optional[str]:
-        """
-        Return the encoding, as detemined by `charset_normalizer`.
-        """
-        content = getattr(self, "_content", b"")
-        if len(content) < 32:
-            # charset_normalizer will issue warnings if we run it with
-            # fewer bytes than this cutoff.
-            return None
-        match = charset_normalizer.from_bytes(self.content).best()
-        return None if match is None else match.encoding
+        return parse_content_type_charset(content_type)
 
     def _get_content_decoder(self) -> ContentDecoder:
         """
@@ -1375,7 +634,7 @@ def _get_content_decoder(self) -> ContentDecoder:
         content, depending on the Content-Encoding used in the response.
         """
         if not hasattr(self, "_decoder"):
-            decoders: typing.List[ContentDecoder] = []
+            decoders: list[ContentDecoder] = []
             values = self.headers.get_list("content-encoding", split_commas=True)
             for value in values:
                 value = value.strip().lower()
@@ -1395,22 +654,79 @@ def _get_content_decoder(self) -> ContentDecoder:
         return self._decoder
 
     @property
-    def is_error(self) -> bool:
-        return codes.is_error(self.status_code)
+    def is_informational(self) -> bool:
+        """
+        A property which is `True` for 1xx status codes, `False` otherwise.
+        """
+        return codes.is_informational(self.status_code)
+
+    @property
+    def is_success(self) -> bool:
+        """
+        A property which is `True` for 2xx status codes, `False` otherwise.
+        """
+        return codes.is_success(self.status_code)
 
     @property
     def is_redirect(self) -> bool:
-        return codes.is_redirect(self.status_code) and "location" in self.headers
+        """
+        A property which is `True` for 3xx status codes, `False` otherwise.
+
+        Note that not all responses with a 3xx status code indicate a URL redirect.
 
-    def raise_for_status(self) -> None:
+        Use `response.has_redirect_location` to determine responses with a properly
+        formed URL redirection.
         """
-        Raise the `HTTPStatusError` if one occurred.
+        return codes.is_redirect(self.status_code)
+
+    @property
+    def is_client_error(self) -> bool:
+        """
+        A property which is `True` for 4xx status codes, `False` otherwise.
+        """
+        return codes.is_client_error(self.status_code)
+
+    @property
+    def is_server_error(self) -> bool:
+        """
+        A property which is `True` for 5xx status codes, `False` otherwise.
+        """
+        return codes.is_server_error(self.status_code)
+
+    @property
+    def is_error(self) -> bool:
         """
-        message = (
-            "{0.status_code} {error_type}: {0.reason_phrase} for url: {0.url}\n"
-            "For more information check: https://httpstatuses.com/{0.status_code}"
+        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
+        """
+        return codes.is_error(self.status_code)
+
+    @property
+    def has_redirect_location(self) -> bool:
+        """
+        Returns True for 3xx responses with a properly formed URL redirection,
+        `False` otherwise.
+        """
+        return (
+            self.status_code
+            in (
+                # 301 (Cacheable redirect. Method may change to GET.)
+                codes.MOVED_PERMANENTLY,
+                # 302 (Uncacheable redirect. Method may change to GET.)
+                codes.FOUND,
+                # 303 (Client should make a GET or HEAD request.)
+                codes.SEE_OTHER,
+                # 307 (Equiv. 302, but retain method)
+                codes.TEMPORARY_REDIRECT,
+                # 308 (Equiv. 301, but retain method)
+                codes.PERMANENT_REDIRECT,
+            )
+            and "Location" in self.headers
         )
 
+    def raise_for_status(self) -> Response:
+        """
+        Raise the `HTTPStatusError` if one occurred.
+        """
         request = self._request
         if request is None:
             raise RuntimeError(
@@ -1418,40 +734,55 @@ def raise_for_status(self) -> None:
                 "instance has not been set on this response."
             )
 
-        if codes.is_client_error(self.status_code):
-            message = message.format(self, error_type="Client Error")
-            raise HTTPStatusError(message, request=request, response=self)
-        elif codes.is_server_error(self.status_code):
-            message = message.format(self, error_type="Server Error")
-            raise HTTPStatusError(message, request=request, response=self)
+        if self.is_success:
+            return self
+
+        if self.has_redirect_location:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "Redirect location: '{0.headers[location]}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+        else:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+
+        status_class = self.status_code // 100
+        error_types = {
+            1: "Informational response",
+            3: "Redirect response",
+            4: "Client error",
+            5: "Server error",
+        }
+        error_type = error_types.get(status_class, "Invalid status code")
+        message = message.format(self, error_type=error_type)
+        raise HTTPStatusError(message, request=request, response=self)
 
     def json(self, **kwargs: typing.Any) -> typing.Any:
-        if self.charset_encoding is None and self.content and len(self.content) > 3:
-            encoding = guess_json_utf(self.content)
-            if encoding is not None:
-                return jsonlib.loads(self.content.decode(encoding), **kwargs)
-        return jsonlib.loads(self.text, **kwargs)
+        return jsonlib.loads(self.content, **kwargs)
 
     @property
-    def cookies(self) -> "Cookies":
+    def cookies(self) -> Cookies:
         if not hasattr(self, "_cookies"):
             self._cookies = Cookies()
             self._cookies.extract_cookies(self)
         return self._cookies
 
     @property
-    def links(self) -> typing.Dict[typing.Optional[str], typing.Dict[str, str]]:
+    def links(self) -> dict[str | None, dict[str, str]]:
         """
         Returns the parsed header links of the response, if any
         """
         header = self.headers.get("link")
-        ldict = {}
-        if header:
-            links = parse_header_links(header)
-            for link in links:
-                key = link.get("rel") or link.get("url")
-                ldict[key] = link
-        return ldict
+        if header is None:
+            return {}
+
+        return {
+            (link.get("rel") or link.get("url")): link
+            for link in parse_header_links(header)
+        }
 
     @property
     def num_bytes_downloaded(self) -> int:
@@ -1460,17 +791,18 @@ def num_bytes_downloaded(self) -> int:
     def __repr__(self) -> str:
         return f"<Response [{self.status_code} {self.reason_phrase}]>"
 
-    def __getstate__(self) -> typing.Dict[str, typing.Any]:
+    def __getstate__(self) -> dict[str, typing.Any]:
         return {
             name: value
             for name, value in self.__dict__.items()
-            if name not in ["stream", "is_closed", "_decoder"]
+            if name not in ["extensions", "stream", "is_closed", "_decoder"]
         }
 
-    def __setstate__(self, state: typing.Dict[str, typing.Any]) -> None:
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
         for name, value in state.items():
             setattr(self, name, value)
         self.is_closed = True
+        self.extensions = {}
         self.stream = UnattachedStream()
 
     def read(self) -> bytes:
@@ -1481,14 +813,14 @@ def read(self) -> bytes:
             self._content = b"".join(self.iter_bytes())
         return self._content
 
-    def iter_bytes(self, chunk_size: int = None) -> typing.Iterator[bytes]:
+    def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
         """
         A byte-iterator over the decoded response content.
         This allows us to handle gzip, deflate, and brotli encoded responses.
         """
         if hasattr(self, "_content"):
             chunk_size = len(self._content) if chunk_size is None else chunk_size
-            for i in range(0, len(self._content), chunk_size):
+            for i in range(0, len(self._content), max(chunk_size, 1)):
                 yield self._content[i : i + chunk_size]
         else:
             decoder = self._get_content_decoder()
@@ -1500,11 +832,11 @@ def iter_bytes(self, chunk_size: int = None) -> typing.Iterator[bytes]:
                         yield chunk
                 decoded = decoder.flush()
                 for chunk in chunker.decode(decoded):
-                    yield chunk
+                    yield chunk  # pragma: no cover
                 for chunk in chunker.flush():
                     yield chunk
 
-    def iter_text(self, chunk_size: int = None) -> typing.Iterator[str]:
+    def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[str]:
         """
         A str-iterator over the decoded response content
         that handles both gzip, deflate, etc but also detects the content's
@@ -1519,7 +851,7 @@ def iter_text(self, chunk_size: int = None) -> typing.Iterator[str]:
                     yield chunk
             text_content = decoder.flush()
             for chunk in chunker.decode(text_content):
-                yield chunk
+                yield chunk  # pragma: no cover
             for chunk in chunker.flush():
                 yield chunk
 
@@ -1532,7 +864,7 @@ def iter_lines(self) -> typing.Iterator[str]:
             for line in decoder.flush():
                 yield line
 
-    def iter_raw(self, chunk_size: int = None) -> typing.Iterator[bytes]:
+    def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
         """
         A byte-iterator over the raw response content.
         """
@@ -1579,14 +911,16 @@ async def aread(self) -> bytes:
             self._content = b"".join([part async for part in self.aiter_bytes()])
         return self._content
 
-    async def aiter_bytes(self, chunk_size: int = None) -> typing.AsyncIterator[bytes]:
+    async def aiter_bytes(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[bytes]:
         """
         A byte-iterator over the decoded response content.
         This allows us to handle gzip, deflate, and brotli encoded responses.
         """
         if hasattr(self, "_content"):
             chunk_size = len(self._content) if chunk_size is None else chunk_size
-            for i in range(0, len(self._content), chunk_size):
+            for i in range(0, len(self._content), max(chunk_size, 1)):
                 yield self._content[i : i + chunk_size]
         else:
             decoder = self._get_content_decoder()
@@ -1598,11 +932,13 @@ async def aiter_bytes(self, chunk_size: int = None) -> typing.AsyncIterator[byte
                         yield chunk
                 decoded = decoder.flush()
                 for chunk in chunker.decode(decoded):
-                    yield chunk
+                    yield chunk  # pragma: no cover
                 for chunk in chunker.flush():
                     yield chunk
 
-    async def aiter_text(self, chunk_size: int = None) -> typing.AsyncIterator[str]:
+    async def aiter_text(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[str]:
         """
         A str-iterator over the decoded response content
         that handles both gzip, deflate, etc but also detects the content's
@@ -1617,7 +953,7 @@ async def aiter_text(self, chunk_size: int = None) -> typing.AsyncIterator[str]:
                     yield chunk
             text_content = decoder.flush()
             for chunk in chunker.decode(text_content):
-                yield chunk
+                yield chunk  # pragma: no cover
             for chunk in chunker.flush():
                 yield chunk
 
@@ -1630,7 +966,9 @@ async def aiter_lines(self) -> typing.AsyncIterator[str]:
             for line in decoder.flush():
                 yield line
 
-    async def aiter_raw(self, chunk_size: int = None) -> typing.AsyncIterator[bytes]:
+    async def aiter_raw(
+        self, chunk_size: int | None = None
+    ) -> typing.AsyncIterator[bytes]:
         """
         A byte-iterator over the raw response content.
         """
@@ -1670,12 +1008,12 @@ async def aclose(self) -> None:
                 await self.stream.aclose()
 
 
-class Cookies(MutableMapping):
+class Cookies(typing.MutableMapping[str, str]):
     """
     HTTP Cookies, as a mutable mapping.
     """
 
-    def __init__(self, cookies: CookieTypes = None) -> None:
+    def __init__(self, cookies: CookieTypes | None = None) -> None:
         if cookies is None or isinstance(cookies, dict):
             self.jar = CookieJar()
             if isinstance(cookies, dict):
@@ -1735,8 +1073,12 @@ def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None:
         self.jar.set_cookie(cookie)
 
     def get(  # type: ignore
-        self, name: str, default: str = None, domain: str = None, path: str = None
-    ) -> typing.Optional[str]:
+        self,
+        name: str,
+        default: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> str | None:
         """
         Get a cookie by name. May optionally include domain and path
         in order to specify exactly which cookie to retrieve.
@@ -1755,7 +1097,12 @@ def get(  # type: ignore
             return default
         return value
 
-    def delete(self, name: str, domain: str = None, path: str = None) -> None:
+    def delete(
+        self,
+        name: str,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> None:
         """
         Delete a cookie by name. May optionally include domain and path
         in order to specify exactly which cookie to delete.
@@ -1774,7 +1121,7 @@ def delete(self, name: str, domain: str = None, path: str = None) -> None:
         for cookie in remove:
             self.jar.clear(cookie.domain, cookie.path, cookie.name)
 
-    def clear(self, domain: str = None, path: str = None) -> None:
+    def clear(self, domain: str | None = None, path: str | None = None) -> None:
         """
         Delete all cookies. Optionally include a domain and path in
         order to only delete a subset of all the cookies.
@@ -1787,7 +1134,7 @@ def clear(self, domain: str = None, path: str = None) -> None:
             args.append(path)
         self.jar.clear(*args)
 
-    def update(self, cookies: CookieTypes = None) -> None:  # type: ignore
+    def update(self, cookies: CookieTypes | None = None) -> None:  # type: ignore
         cookies = Cookies(cookies)
         for cookie in cookies.jar:
             self.jar.set_cookie(cookie)
@@ -1849,7 +1196,7 @@ class _CookieCompatResponse:
         for use with `CookieJar` operations.
         """
 
-        def __init__(self, response: Response):
+        def __init__(self, response: Response) -> None:
             self.response = response
 
         def info(self) -> email.message.Message:
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_multipart.py b/addon/globalPlugins/spellcheck/libs/httpx/_multipart.py
index 683e6f1..8edb622 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_multipart.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_multipart.py
@@ -1,11 +1,18 @@
-import binascii
+from __future__ import annotations
+
 import io
 import os
 import typing
 from pathlib import Path
 
-from ._transports.base import AsyncByteStream, SyncByteStream
-from ._types import FileContent, FileTypes, RequestFiles
+from ._types import (
+    AsyncByteStream,
+    FileContent,
+    FileTypes,
+    RequestData,
+    RequestFiles,
+    SyncByteStream,
+)
 from ._utils import (
     format_form_param,
     guess_content_type,
@@ -15,24 +22,37 @@
 )
 
 
+def get_multipart_boundary_from_content_type(
+    content_type: bytes | None,
+) -> bytes | None:
+    if not content_type or not content_type.startswith(b"multipart/form-data"):
+        return None
+    # parse boundary according to
+    # https://www.rfc-editor.org/rfc/rfc2046#section-5.1.1
+    if b";" in content_type:
+        for section in content_type.split(b";"):
+            if section.strip().lower().startswith(b"boundary="):
+                return section.strip()[len(b"boundary=") :].strip(b'"')
+    return None
+
+
 class DataField:
     """
     A single form field item, within a multipart form field.
     """
 
-    def __init__(
-        self, name: str, value: typing.Union[str, bytes, int, float, None]
-    ) -> None:
+    def __init__(self, name: str, value: str | bytes | int | float | None) -> None:
         if not isinstance(name, str):
             raise TypeError(
                 f"Invalid type for name. Expected str, got {type(name)}: {name!r}"
             )
         if value is not None and not isinstance(value, (str, bytes, int, float)):
             raise TypeError(
-                f"Invalid type for value. Expected primitive type, got {type(value)}: {value!r}"
+                "Invalid type for value. Expected primitive type,"
+                f" got {type(value)}: {value!r}"
             )
         self.name = name
-        self.value: typing.Union[str, bytes] = (
+        self.value: str | bytes = (
             value if isinstance(value, bytes) else primitive_value_to_str(value)
         )
 
@@ -66,43 +86,69 @@ class FileField:
     A single file field item, within a multipart form field.
     """
 
+    CHUNK_SIZE = 64 * 1024
+
     def __init__(self, name: str, value: FileTypes) -> None:
         self.name = name
 
         fileobj: FileContent
 
+        headers: dict[str, str] = {}
+        content_type: str | None = None
+
+        # This large tuple based API largely mirror's requests' API
+        # It would be good to think of better APIs for this that we could
+        # include in httpx 2.0 since variable length tuples(especially of 4 elements)
+        # are quite unwieldly
         if isinstance(value, tuple):
-            try:
-                filename, fileobj, content_type = value  # type: ignore
-            except ValueError:
-                filename, fileobj = value  # type: ignore
-                content_type = guess_content_type(filename)
+            if len(value) == 2:
+                # neither the 3rd parameter (content_type) nor the 4th (headers)
+                # was included
+                filename, fileobj = value
+            elif len(value) == 3:
+                filename, fileobj, content_type = value
+            else:
+                # all 4 parameters included
+                filename, fileobj, content_type, headers = value  # type: ignore
         else:
             filename = Path(str(getattr(value, "name", "upload"))).name
             fileobj = value
+
+        if content_type is None:
             content_type = guess_content_type(filename)
 
-        if isinstance(fileobj, str) or isinstance(fileobj, io.StringIO):
-            raise TypeError(f"Expected bytes or bytes-like object got: {type(fileobj)}")
+        has_content_type_header = any("content-type" in key.lower() for key in headers)
+        if content_type is not None and not has_content_type_header:
+            # note that unlike requests, we ignore the content_type provided in the 3rd
+            # tuple element if it is also included in the headers requests does
+            # the opposite (it overwrites the headerwith the 3rd tuple element)
+            headers["Content-Type"] = content_type
+
+        if isinstance(fileobj, io.StringIO):
+            raise TypeError(
+                "Multipart file uploads require 'io.BytesIO', not 'io.StringIO'."
+            )
+        if isinstance(fileobj, io.TextIOBase):
+            raise TypeError(
+                "Multipart file uploads must be opened in binary mode, not text mode."
+            )
 
         self.filename = filename
         self.file = fileobj
-        self.content_type = content_type
-        self._consumed = False
+        self.headers = headers
 
-    def get_length(self) -> int:
+    def get_length(self) -> int | None:
         headers = self.render_headers()
 
         if isinstance(self.file, (str, bytes)):
             return len(headers) + len(to_bytes(self.file))
 
-        # Let's do our best not to read `file` into memory.
         file_length = peek_filelike_length(self.file)
+
+        # If we can't determine the filesize without reading it into memory,
+        # then return `None` here, to indicate an unknown file length.
         if file_length is None:
-            # As a last resort, read file and cache contents for later.
-            assert not hasattr(self, "_data")
-            self._data = to_bytes(self.file.read())
-            file_length = len(self._data)
+            return None
 
         return len(headers) + file_length
 
@@ -115,9 +161,9 @@ def render_headers(self) -> bytes:
             if self.filename:
                 filename = format_form_param("filename", self.filename)
                 parts.extend([b"; ", filename])
-            if self.content_type is not None:
-                content_type = self.content_type.encode()
-                parts.extend([b"\r\nContent-Type: ", content_type])
+            for header_name, header_value in self.headers.items():
+                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
+                parts.extend([key, val])
             parts.append(b"\r\n\r\n")
             self._headers = b"".join(parts)
 
@@ -128,17 +174,16 @@ def render_data(self) -> typing.Iterator[bytes]:
             yield to_bytes(self.file)
             return
 
-        if hasattr(self, "_data"):
-            # Already rendered.
-            yield self._data
-            return
-
-        if self._consumed:  # pragma: nocover
-            self.file.seek(0)
-        self._consumed = True
+        if hasattr(self.file, "seek"):
+            try:
+                self.file.seek(0)
+            except io.UnsupportedOperation:
+                pass
 
-        for chunk in self.file:
+        chunk = self.file.read(self.CHUNK_SIZE)
+        while chunk:
             yield to_bytes(chunk)
+            chunk = self.file.read(self.CHUNK_SIZE)
 
     def render(self) -> typing.Iterator[bytes]:
         yield self.render_headers()
@@ -150,9 +195,14 @@ class MultipartStream(SyncByteStream, AsyncByteStream):
     Request content as streaming multipart encoded form data.
     """
 
-    def __init__(self, data: dict, files: RequestFiles, boundary: bytes = None) -> None:
+    def __init__(
+        self,
+        data: RequestData,
+        files: RequestFiles,
+        boundary: bytes | None = None,
+    ) -> None:
         if boundary is None:
-            boundary = binascii.hexlify(os.urandom(16))
+            boundary = os.urandom(16).hex().encode("ascii")
 
         self.boundary = boundary
         self.content_type = "multipart/form-data; boundary=%s" % boundary.decode(
@@ -161,10 +211,10 @@ def __init__(self, data: dict, files: RequestFiles, boundary: bytes = None) -> N
         self.fields = list(self._iter_fields(data, files))
 
     def _iter_fields(
-        self, data: dict, files: RequestFiles
-    ) -> typing.Iterator[typing.Union[FileField, DataField]]:
+        self, data: RequestData, files: RequestFiles
+    ) -> typing.Iterator[FileField | DataField]:
         for name, value in data.items():
-            if isinstance(value, list):
+            if isinstance(value, (tuple, list)):
                 for item in value:
                     yield DataField(name=name, value=item)
             else:
@@ -181,24 +231,34 @@ def iter_chunks(self) -> typing.Iterator[bytes]:
             yield b"\r\n"
         yield b"--%s--\r\n" % self.boundary
 
-    def iter_chunks_lengths(self) -> typing.Iterator[int]:
+    def get_content_length(self) -> int | None:
+        """
+        Return the length of the multipart encoded content, or `None` if
+        any of the files have a length that cannot be determined upfront.
+        """
         boundary_length = len(self.boundary)
-        # Follow closely what `.iter_chunks()` does.
+        length = 0
+
         for field in self.fields:
-            yield 2 + boundary_length + 2
-            yield field.get_length()
-            yield 2
-        yield 2 + boundary_length + 4
+            field_length = field.get_length()
+            if field_length is None:
+                return None
+
+            length += 2 + boundary_length + 2  # b"--{boundary}\r\n"
+            length += field_length
+            length += 2  # b"\r\n"
 
-    def get_content_length(self) -> int:
-        return sum(self.iter_chunks_lengths())
+        length += 2 + boundary_length + 4  # b"--{boundary}--\r\n"
+        return length
 
     # Content stream interface.
 
-    def get_headers(self) -> typing.Dict[str, str]:
-        content_length = str(self.get_content_length())
+    def get_headers(self) -> dict[str, str]:
+        content_length = self.get_content_length()
         content_type = self.content_type
-        return {"Content-Length": content_length, "Content-Type": content_type}
+        if content_length is None:
+            return {"Transfer-Encoding": "chunked", "Content-Type": content_type}
+        return {"Content-Length": str(content_length), "Content-Type": content_type}
 
     def __iter__(self) -> typing.Iterator[bytes]:
         for chunk in self.iter_chunks():
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_status_codes.py b/addon/globalPlugins/spellcheck/libs/httpx/_status_codes.py
index 100aec6..4cde4e6 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_status_codes.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_status_codes.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from enum import IntEnum
 
 
@@ -21,11 +23,11 @@ class codes(IntEnum):
         * RFC 8470: Using Early Data in HTTP
     """
 
-    def __new__(cls, value: int, phrase: str = "") -> "codes":
-        obj = int.__new__(cls, value)  # type: ignore
+    def __new__(cls, value: int, phrase: str = "") -> codes:
+        obj = int.__new__(cls, value)
         obj._value_ = value
 
-        obj.phrase = phrase  # type: ignore
+        obj.phrase = phrase  # type: ignore[attr-defined]
         return obj
 
     def __str__(self) -> str:
@@ -39,32 +41,47 @@ def get_reason_phrase(cls, value: int) -> str:
             return ""
 
     @classmethod
-    def is_redirect(cls, value: int) -> bool:
-        return value in (
-            # 301 (Cacheable redirect. Method may change to GET.)
-            codes.MOVED_PERMANENTLY,
-            # 302 (Uncacheable redirect. Method may change to GET.)
-            codes.FOUND,
-            # 303 (Client should make a GET or HEAD request.)
-            codes.SEE_OTHER,
-            # 307 (Equiv. 302, but retain method)
-            codes.TEMPORARY_REDIRECT,
-            # 308 (Equiv. 301, but retain method)
-            codes.PERMANENT_REDIRECT,
-        )
+    def is_informational(cls, value: int) -> bool:
+        """
+        Returns `True` for 1xx status codes, `False` otherwise.
+        """
+        return 100 <= value <= 199
 
     @classmethod
-    def is_error(cls, value: int) -> bool:
-        return 400 <= value <= 599
+    def is_success(cls, value: int) -> bool:
+        """
+        Returns `True` for 2xx status codes, `False` otherwise.
+        """
+        return 200 <= value <= 299
+
+    @classmethod
+    def is_redirect(cls, value: int) -> bool:
+        """
+        Returns `True` for 3xx status codes, `False` otherwise.
+        """
+        return 300 <= value <= 399
 
     @classmethod
     def is_client_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx status codes, `False` otherwise.
+        """
         return 400 <= value <= 499
 
     @classmethod
     def is_server_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 5xx status codes, `False` otherwise.
+        """
         return 500 <= value <= 599
 
+    @classmethod
+    def is_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 599
+
     # informational
     CONTINUE = 100, "Continue"
     SWITCHING_PROTOCOLS = 101, "Switching Protocols"
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_transports/asgi.py b/addon/globalPlugins/spellcheck/libs/httpx/_transports/asgi.py
index 24c5452..9543a12 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_transports/asgi.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_transports/asgi.py
@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import typing
-from urllib.parse import unquote
 
 import sniffio
 
-from .base import AsyncBaseTransport, AsyncByteStream
+from .._models import Request, Response
+from .._types import AsyncByteStream
+from .base import AsyncBaseTransport
 
 if typing.TYPE_CHECKING:  # pragma: no cover
     import asyncio
@@ -13,7 +16,17 @@
     Event = typing.Union[asyncio.Event, trio.Event]
 
 
-def create_event() -> "Event":
+_Message = typing.Dict[str, typing.Any]
+_Receive = typing.Callable[[], typing.Awaitable[_Message]]
+_Send = typing.Callable[
+    [typing.Dict[str, typing.Any]], typing.Coroutine[None, None, None]
+]
+_ASGIApp = typing.Callable[
+    [typing.Dict[str, typing.Any], _Receive, _Send], typing.Coroutine[None, None, None]
+]
+
+
+def create_event() -> Event:
     if sniffio.current_async_library() == "trio":
         import trio
 
@@ -25,7 +38,7 @@ def create_event() -> "Event":
 
 
 class ASGIResponseStream(AsyncByteStream):
-    def __init__(self, body: typing.List[bytes]) -> None:
+    def __init__(self, body: list[bytes]) -> None:
         self._body = body
 
     async def __aiter__(self) -> typing.AsyncIterator[bytes]:
@@ -67,10 +80,10 @@ class ASGITransport(AsyncBaseTransport):
 
     def __init__(
         self,
-        app: typing.Callable,
+        app: _ASGIApp,
         raise_app_exceptions: bool = True,
         root_path: str = "",
-        client: typing.Tuple[str, int] = ("127.0.0.1", 123),
+        client: tuple[str, int] = ("127.0.0.1", 123),
     ) -> None:
         self.app = app
         self.raise_app_exceptions = raise_app_exceptions
@@ -79,34 +92,28 @@ def __init__(
 
     async def handle_async_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], AsyncByteStream, dict
-    ]:
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
         # ASGI scope.
-        scheme, host, port, full_path = url
-        path, _, query = full_path.partition(b"?")
         scope = {
             "type": "http",
             "asgi": {"version": "3.0"},
             "http_version": "1.1",
-            "method": method.decode(),
-            "headers": [(k.lower(), v) for (k, v) in headers],
-            "scheme": scheme.decode("ascii"),
-            "path": unquote(path.decode("ascii")),
-            "raw_path": path,
-            "query_string": query,
-            "server": (host.decode("ascii"), port),
+            "method": request.method,
+            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
+            "scheme": request.url.scheme,
+            "path": request.url.path,
+            "raw_path": request.url.raw_path.split(b"?")[0],
+            "query_string": request.url.query,
+            "server": (request.url.host, request.url.port),
             "client": self.client,
             "root_path": self.root_path,
         }
 
         # Request.
-        request_body_chunks = stream.__aiter__()
+        request_body_chunks = request.stream.__aiter__()
         request_complete = False
 
         # Response.
@@ -118,7 +125,7 @@ async def handle_async_request(
 
         # ASGI callables.
 
-        async def receive() -> dict:
+        async def receive() -> dict[str, typing.Any]:
             nonlocal request_complete
 
             if request_complete:
@@ -132,7 +139,7 @@ async def receive() -> dict:
                 return {"type": "http.request", "body": b"", "more_body": False}
             return {"type": "http.request", "body": body, "more_body": True}
 
-        async def send(message: dict) -> None:
+        async def send(message: dict[str, typing.Any]) -> None:
             nonlocal status_code, response_headers, response_started
 
             if message["type"] == "http.response.start":
@@ -147,7 +154,7 @@ async def send(message: dict) -> None:
                 body = message.get("body", b"")
                 more_body = message.get("more_body", False)
 
-                if body and method != b"HEAD":
+                if body and request.method != "HEAD":
                     body_parts.append(body)
 
                 if not more_body:
@@ -155,15 +162,20 @@ async def send(message: dict) -> None:
 
         try:
             await self.app(scope, receive, send)
-        except Exception:
-            if self.raise_app_exceptions or not response_complete.is_set():
+        except Exception:  # noqa: PIE-786
+            if self.raise_app_exceptions:
                 raise
 
+            response_complete.set()
+            if status_code is None:
+                status_code = 500
+            if response_headers is None:
+                response_headers = {}
+
         assert response_complete.is_set()
         assert status_code is not None
         assert response_headers is not None
 
         stream = ASGIResponseStream(body_parts)
-        extensions = {}
 
-        return (status_code, response_headers, stream, extensions)
+        return Response(status_code, headers=response_headers, stream=stream)
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_transports/base.py b/addon/globalPlugins/spellcheck/libs/httpx/_transports/base.py
index eb51926..8b6dc3c 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_transports/base.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_transports/base.py
@@ -1,153 +1,60 @@
+from __future__ import annotations
+
 import typing
 from types import TracebackType
 
+from .._models import Request, Response
+
 T = typing.TypeVar("T", bound="BaseTransport")
 A = typing.TypeVar("A", bound="AsyncBaseTransport")
 
 
-class SyncByteStream:
-    def __iter__(self) -> typing.Iterator[bytes]:
-        raise NotImplementedError(
-            "The '__iter__' method must be implemented."
-        )  # pragma: nocover
-        yield b""  # pragma: nocover
-
-    def close(self) -> None:
-        """
-        Subclasses can override this method to release any network resources
-        after a request/response cycle is complete.
-
-        Streaming cases should use a `try...finally` block to ensure that
-        the stream `close()` method is always called.
-
-        Example:
-
-            status_code, headers, stream, extensions = transport.handle_request(...)
-            try:
-                ...
-            finally:
-                stream.close()
-        """
-
-    def read(self) -> bytes:
-        """
-        Simple cases can use `.read()` as a convience method for consuming
-        the entire stream and then closing it.
-
-        Example:
-
-            status_code, headers, stream, extensions = transport.handle_request(...)
-            body = stream.read()
-        """
-        try:
-            return b"".join([part for part in self])
-        finally:
-            self.close()
-
-
-class AsyncByteStream:
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        raise NotImplementedError(
-            "The '__aiter__' method must be implemented."
-        )  # pragma: nocover
-        yield b""  # pragma: nocover
-
-    async def aclose(self) -> None:
-        pass
-
-    async def aread(self) -> bytes:
-        try:
-            return b"".join([part async for part in self])
-        finally:
-            await self.aclose()
-
-
 class BaseTransport:
     def __enter__(self: T) -> T:
         return self
 
     def __exit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         self.close()
 
-    def handle_request(
-        self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], SyncByteStream, dict
-    ]:
+    def handle_request(self, request: Request) -> Response:
         """
         Send a single HTTP request and return a response.
 
-        At this layer of API we're simply using plain primitives. No `Request` or
-        `Response` models, no fancy `URL` or `Header` handling. This strict point
-        of cut-off provides a clear design seperation between the HTTPX API,
-        and the low-level network handling.
-
         Developers shouldn't typically ever need to call into this API directly,
         since the Client class provides all the higher level user-facing API
         niceties.
 
-        In order to properly release any network resources, the response stream
-        should *either* be consumed immediately, with a call to `stream.read()`,
-        or else the `handle_request` call should be followed with a try/finally
-        block to ensuring the stream is always closed.
+        In order to properly release any network resources, the response
+        stream should *either* be consumed immediately, with a call to
+        `response.stream.read()`, or else the `handle_request` call should
+        be followed with a try/finally block to ensuring the stream is
+        always closed.
 
         Example usage:
 
             with httpx.HTTPTransport() as transport:
-                status_code, headers, stream, extensions = transport.handle_request(
-                    method=b'GET',
-                    url=(b'https', b'www.example.com', 443, b'/'),
-                    headers=[(b'Host', b'www.example.com')],
-                    stream=[],
-                    extensions={}
+                req = httpx.Request(
+                    method=b"GET",
+                    url=(b"https", b"www.example.com", 443, b"/"),
+                    headers=[(b"Host", b"www.example.com")],
                 )
-                body = stream.read()
-                print(status_code, headers, body)
-
-        Arguments:
-
-        method: The request method as bytes. Eg. b'GET'.
-        url: The components of the request URL, as a tuple of `(scheme, host, port, target)`.
-             The target will usually be the URL path, but also allows for alternative
-             formulations, such as proxy requests which include the complete URL in
-             the target portion of the HTTP request, or for "OPTIONS *" requests, which
-             cannot be expressed in a URL string.
-        headers: The request headers as a list of byte pairs.
-        stream: The request body as a bytes iterator.
-        extensions: An open ended dictionary, including optional extensions to the
-                    core request/response API. Keys may include:
-            timeout: A dictionary of str:Optional[float] timeout values.
-                     May include values for 'connect', 'read', 'write', or 'pool'.
-
-        Returns a tuple of:
-
-        status_code: The response status code as an integer. Should be in the range 1xx-5xx.
-        headers: The response headers as a list of byte pairs.
-        stream: The response body as a bytes iterator.
-        extensions: An open ended dictionary, including optional extensions to the
-                    core request/response API. Keys are plain strings, and may include:
-            reason_phrase: The reason-phrase of the HTTP response, as bytes. Eg b'OK'.
-                    HTTP/2 onwards does not include a reason phrase on the wire.
-                    When no key is included, a default based on the status code may
-                    be used. An empty-string reason phrase should not be substituted
-                    for a default, as it indicates the server left the portion blank
-                    eg. the leading response bytes were b"HTTP/1.1 200 <CRLF>".
-            http_version: The HTTP version, as bytes. Eg. b"HTTP/1.1".
-                    When no http_version key is included, HTTP/1.1 may be assumed.
+                resp = transport.handle_request(req)
+                body = resp.stream.read()
+                print(resp.status_code, resp.headers, body)
+
+
+        Takes a `Request` instance as the only argument.
+
+        Returns a `Response` instance.
         """
         raise NotImplementedError(
             "The 'handle_request' method must be implemented."
-        )  # pragma: nocover
+        )  # pragma: no cover
 
     def close(self) -> None:
         pass
@@ -159,25 +66,19 @@ async def __aenter__(self: A) -> A:
 
     async def __aexit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         await self.aclose()
 
     async def handle_async_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], AsyncByteStream, dict
-    ]:
+        request: Request,
+    ) -> Response:
         raise NotImplementedError(
             "The 'handle_async_request' method must be implemented."
-        )  # pragma: nocover
+        )  # pragma: no cover
 
     async def aclose(self) -> None:
         pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_transports/default.py b/addon/globalPlugins/spellcheck/libs/httpx/_transports/default.py
index 73401fc..14476a3 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_transports/default.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_transports/default.py
@@ -6,11 +6,10 @@
 * uds: str
 * local_address: str
 * retries: int
-* backend: str ("auto", "asyncio", "trio", "curio", "anyio", "sync")
 
 Example usages...
 
-# Disable HTTP/2 on a single specfic domain.
+# Disable HTTP/2 on a single specific domain.
 mounts = {
     "all://": httpx.HTTPTransport(http2=True),
     "all://*example.org": httpx.HTTPTransport()
@@ -24,6 +23,8 @@
 transport = httpx.HTTPTransport(uds="socket.uds")
 client = httpx.Client(transport=transport)
 """
+from __future__ import annotations
+
 import contextlib
 import typing
 from types import TracebackType
@@ -32,7 +33,6 @@
 
 from .._config import DEFAULT_LIMITS, Limits, Proxy, create_ssl_context
 from .._exceptions import (
-    CloseError,
     ConnectError,
     ConnectTimeout,
     LocalProtocolError,
@@ -48,12 +48,20 @@
     WriteError,
     WriteTimeout,
 )
-from .._types import CertTypes, VerifyTypes
-from .base import AsyncBaseTransport, AsyncByteStream, BaseTransport, SyncByteStream
+from .._models import Request, Response
+from .._types import AsyncByteStream, CertTypes, ProxyTypes, SyncByteStream, VerifyTypes
+from .._urls import URL
+from .base import AsyncBaseTransport, BaseTransport
 
 T = typing.TypeVar("T", bound="HTTPTransport")
 A = typing.TypeVar("A", bound="AsyncHTTPTransport")
 
+SOCKET_OPTION = typing.Union[
+    typing.Tuple[int, int, int],
+    typing.Tuple[int, int, typing.Union[bytes, bytearray]],
+    typing.Tuple[int, int, None, int],
+]
+
 
 @contextlib.contextmanager
 def map_httpcore_exceptions() -> typing.Iterator[None]:
@@ -71,7 +79,7 @@ def map_httpcore_exceptions() -> typing.Iterator[None]:
             if mapped_exc is None or issubclass(to_exc, mapped_exc):
                 mapped_exc = to_exc
 
-        if mapped_exc is None:  # pragma: nocover
+        if mapped_exc is None:  # pragma: no cover
             raise
 
         message = str(exc)
@@ -88,7 +96,6 @@ def map_httpcore_exceptions() -> typing.Iterator[None]:
     httpcore.ConnectError: ConnectError,
     httpcore.ReadError: ReadError,
     httpcore.WriteError: WriteError,
-    httpcore.CloseError: CloseError,
     httpcore.ProxyError: ProxyError,
     httpcore.UnsupportedProtocol: UnsupportedProtocol,
     httpcore.ProtocolError: ProtocolError,
@@ -98,7 +105,7 @@ def map_httpcore_exceptions() -> typing.Iterator[None]:
 
 
 class ResponseStream(SyncByteStream):
-    def __init__(self, httpcore_stream: httpcore.SyncByteStream):
+    def __init__(self, httpcore_stream: typing.Iterable[bytes]) -> None:
         self._httpcore_stream = httpcore_stream
 
     def __iter__(self) -> typing.Iterator[bytes]:
@@ -107,7 +114,7 @@ def __iter__(self) -> typing.Iterator[bytes]:
                 yield part
 
     def close(self) -> None:
-        with map_httpcore_exceptions():
+        if hasattr(self._httpcore_stream, "close"):
             self._httpcore_stream.close()
 
 
@@ -115,21 +122,22 @@ class HTTPTransport(BaseTransport):
     def __init__(
         self,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
         trust_env: bool = True,
-        proxy: Proxy = None,
-        uds: str = None,
-        local_address: str = None,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
         retries: int = 0,
-        backend: str = "sync",
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
     ) -> None:
         ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
 
         if proxy is None:
-            self._pool = httpcore.SyncConnectionPool(
+            self._pool = httpcore.ConnectionPool(
                 ssl_context=ssl_context,
                 max_connections=limits.max_connections,
                 max_keepalive_connections=limits.max_keepalive_connections,
@@ -139,18 +147,55 @@ def __init__(
                 uds=uds,
                 local_address=local_address,
                 retries=retries,
-                backend=backend,
+                socket_options=socket_options,
             )
-        else:
-            self._pool = httpcore.SyncHTTPProxy(
-                proxy_url=proxy.url.raw,
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore.HTTPProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
                 proxy_headers=proxy.headers.raw,
                 ssl_context=ssl_context,
+                proxy_ssl_context=proxy.ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme == "socks5":
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.SOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
                 max_connections=limits.max_connections,
                 max_keepalive_connections=limits.max_keepalive_connections,
                 keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
                 http2=http2,
-                backend=backend,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                "Proxy protocol must be either 'http', 'https', or 'socks5',"
+                f" but got {proxy.url.scheme!r}."
             )
 
     def __enter__(self: T) -> T:  # Use generics for subclass support.
@@ -159,42 +204,49 @@ def __enter__(self: T) -> T:  # Use generics for subclass support.
 
     def __exit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         with map_httpcore_exceptions():
             self._pool.__exit__(exc_type, exc_value, traceback)
 
     def handle_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], SyncByteStream, dict
-    ]:
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, SyncByteStream)
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
         with map_httpcore_exceptions():
-            status_code, headers, byte_stream, extensions = self._pool.handle_request(
-                method=method,
-                url=url,
-                headers=headers,
-                stream=httpcore.IteratorByteStream(iter(stream)),
-                extensions=extensions,
-            )
+            resp = self._pool.handle_request(req)
 
-        stream = ResponseStream(byte_stream)
+        assert isinstance(resp.stream, typing.Iterable)
 
-        return status_code, headers, stream, extensions
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=ResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
 
     def close(self) -> None:
         self._pool.close()
 
 
 class AsyncResponseStream(AsyncByteStream):
-    def __init__(self, httpcore_stream: httpcore.AsyncByteStream):
+    def __init__(self, httpcore_stream: typing.AsyncIterable[bytes]) -> None:
         self._httpcore_stream = httpcore_stream
 
     async def __aiter__(self) -> typing.AsyncIterator[bytes]:
@@ -203,7 +255,7 @@ async def __aiter__(self) -> typing.AsyncIterator[bytes]:
                 yield part
 
     async def aclose(self) -> None:
-        with map_httpcore_exceptions():
+        if hasattr(self._httpcore_stream, "aclose"):
             await self._httpcore_stream.aclose()
 
 
@@ -211,18 +263,19 @@ class AsyncHTTPTransport(AsyncBaseTransport):
     def __init__(
         self,
         verify: VerifyTypes = True,
-        cert: CertTypes = None,
+        cert: CertTypes | None = None,
         http1: bool = True,
         http2: bool = False,
         limits: Limits = DEFAULT_LIMITS,
         trust_env: bool = True,
-        proxy: Proxy = None,
-        uds: str = None,
-        local_address: str = None,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
         retries: int = 0,
-        backend: str = "auto",
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
     ) -> None:
         ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
 
         if proxy is None:
             self._pool = httpcore.AsyncConnectionPool(
@@ -235,18 +288,54 @@ def __init__(
                 uds=uds,
                 local_address=local_address,
                 retries=retries,
-                backend=backend,
+                socket_options=socket_options,
             )
-        else:
+        elif proxy.url.scheme in ("http", "https"):
             self._pool = httpcore.AsyncHTTPProxy(
-                proxy_url=proxy.url.raw,
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
                 proxy_headers=proxy.headers.raw,
                 ssl_context=ssl_context,
                 max_connections=limits.max_connections,
                 max_keepalive_connections=limits.max_keepalive_connections,
                 keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme == "socks5":
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore.AsyncSOCKSProxy(
+                proxy_url=httpcore.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
                 http2=http2,
-                backend=backend,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                "Proxy protocol must be either 'http', 'https', or 'socks5',"
+                " but got {proxy.url.scheme!r}."
             )
 
     async def __aenter__(self: A) -> A:  # Use generics for subclass support.
@@ -255,40 +344,42 @@ async def __aenter__(self: A) -> A:  # Use generics for subclass support.
 
     async def __aexit__(
         self,
-        exc_type: typing.Type[BaseException] = None,
-        exc_value: BaseException = None,
-        traceback: TracebackType = None,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
     ) -> None:
         with map_httpcore_exceptions():
             await self._pool.__aexit__(exc_type, exc_value, traceback)
 
     async def handle_async_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], AsyncByteStream, dict
-    ]:
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        req = httpcore.Request(
+            method=request.method,
+            url=httpcore.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
         with map_httpcore_exceptions():
-            (
-                status_code,
-                headers,
-                byte_stream,
-                extensions,
-            ) = await self._pool.handle_async_request(
-                method=method,
-                url=url,
-                headers=headers,
-                stream=httpcore.AsyncIteratorByteStream(stream.__aiter__()),
-                extensions=extensions,
-            )
+            resp = await self._pool.handle_async_request(req)
 
-        stream = AsyncResponseStream(byte_stream)
+        assert isinstance(resp.stream, typing.AsyncIterable)
 
-        return status_code, headers, stream, extensions
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=AsyncResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
 
     async def aclose(self) -> None:
         await self._pool.aclose()
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_transports/mock.py b/addon/globalPlugins/spellcheck/libs/httpx/_transports/mock.py
index 8d59b73..5abea83 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_transports/mock.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_transports/mock.py
@@ -1,70 +1,40 @@
-import asyncio
+from __future__ import annotations
+
 import typing
 
-from .._models import Request
-from .base import AsyncBaseTransport, AsyncByteStream, BaseTransport, SyncByteStream
+from .._models import Request, Response
+from .base import AsyncBaseTransport, BaseTransport
+
+SyncHandler = typing.Callable[[Request], Response]
+AsyncHandler = typing.Callable[[Request], typing.Coroutine[None, None, Response]]
 
 
 class MockTransport(AsyncBaseTransport, BaseTransport):
-    def __init__(self, handler: typing.Callable) -> None:
+    def __init__(self, handler: SyncHandler | AsyncHandler) -> None:
         self.handler = handler
 
     def handle_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], SyncByteStream, dict
-    ]:
-        request = Request(
-            method=method,
-            url=url,
-            headers=headers,
-            stream=stream,
-        )
+        request: Request,
+    ) -> Response:
         request.read()
         response = self.handler(request)
-        return (
-            response.status_code,
-            response.headers.raw,
-            response.stream,
-            response.extensions,
-        )
+        if not isinstance(response, Response):  # pragma: no cover
+            raise TypeError("Cannot use an async handler in a sync Client")
+        return response
 
     async def handle_async_request(
         self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: AsyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], AsyncByteStream, dict
-    ]:
-        request = Request(
-            method=method,
-            url=url,
-            headers=headers,
-            stream=stream,
-        )
+        request: Request,
+    ) -> Response:
         await request.aread()
-
         response = self.handler(request)
 
         # Allow handler to *optionally* be an `async` function.
         # If it is, then the `response` variable need to be awaited to actually
         # return the result.
 
-        # https://simonwillison.net/2020/Sep/2/await-me-maybe/
-        if asyncio.iscoroutine(response):
+        if not isinstance(response, Response):
             response = await response
 
-        return (
-            response.status_code,
-            response.headers.raw,
-            response.stream,
-            response.extensions,
-        )
+        return response
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_transports/wsgi.py b/addon/globalPlugins/spellcheck/libs/httpx/_transports/wsgi.py
index 58e8309..cd03a94 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_transports/wsgi.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_transports/wsgi.py
@@ -1,12 +1,22 @@
+from __future__ import annotations
+
 import io
 import itertools
+import sys
 import typing
-from urllib.parse import unquote
 
-from .base import BaseTransport, SyncByteStream
+from .._models import Request, Response
+from .._types import SyncByteStream
+from .base import BaseTransport
+
+if typing.TYPE_CHECKING:
+    from _typeshed import OptExcInfo  # pragma: no cover
+    from _typeshed.wsgi import WSGIApplication  # pragma: no cover
+
+_T = typing.TypeVar("_T")
 
 
-def _skip_leading_empty_chunks(body: typing.Iterable) -> typing.Iterable:
+def _skip_leading_empty_chunks(body: typing.Iterable[_T]) -> typing.Iterable[_T]:
     body = iter(body)
     for chunk in body:
         if chunk:
@@ -16,12 +26,17 @@ def _skip_leading_empty_chunks(body: typing.Iterable) -> typing.Iterable:
 
 class WSGIByteStream(SyncByteStream):
     def __init__(self, result: typing.Iterable[bytes]) -> None:
+        self._close = getattr(result, "close", None)
         self._result = _skip_leading_empty_chunks(result)
 
     def __iter__(self) -> typing.Iterator[bytes]:
         for part in self._result:
             yield part
 
+    def close(self) -> None:
+        if self._close is not None:
+            self._close()
+
 
 class WSGITransport(BaseTransport):
     """
@@ -47,7 +62,7 @@ class WSGITransport(BaseTransport):
 
     Arguments:
 
-    * `app` - The ASGI application.
+    * `app` - The WSGI application.
     * `raise_app_exceptions` - Boolean indicating if exceptions in the application
        should be raised. Default to `True`. Can be set to `False` for use cases
        such as testing the content of a client 500 response.
@@ -58,50 +73,41 @@ class WSGITransport(BaseTransport):
 
     def __init__(
         self,
-        app: typing.Callable,
+        app: WSGIApplication,
         raise_app_exceptions: bool = True,
         script_name: str = "",
         remote_addr: str = "127.0.0.1",
+        wsgi_errors: typing.TextIO | None = None,
     ) -> None:
         self.app = app
         self.raise_app_exceptions = raise_app_exceptions
         self.script_name = script_name
         self.remote_addr = remote_addr
+        self.wsgi_errors = wsgi_errors
 
-    def handle_request(
-        self,
-        method: bytes,
-        url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes],
-        headers: typing.List[typing.Tuple[bytes, bytes]],
-        stream: SyncByteStream,
-        extensions: dict,
-    ) -> typing.Tuple[
-        int, typing.List[typing.Tuple[bytes, bytes]], SyncByteStream, dict
-    ]:
-        wsgi_input = io.BytesIO(b"".join(stream))
-
-        scheme, host, port, full_path = url
-        path, _, query = full_path.partition(b"?")
-        if port is None:
-            port = {b"http": 80, b"https": 443}[scheme]
+    def handle_request(self, request: Request) -> Response:
+        request.read()
+        wsgi_input = io.BytesIO(request.content)
 
+        port = request.url.port or {"http": 80, "https": 443}[request.url.scheme]
         environ = {
             "wsgi.version": (1, 0),
-            "wsgi.url_scheme": scheme.decode("ascii"),
+            "wsgi.url_scheme": request.url.scheme,
             "wsgi.input": wsgi_input,
-            "wsgi.errors": io.BytesIO(),
+            "wsgi.errors": self.wsgi_errors or sys.stderr,
             "wsgi.multithread": True,
             "wsgi.multiprocess": False,
             "wsgi.run_once": False,
-            "REQUEST_METHOD": method.decode(),
+            "REQUEST_METHOD": request.method,
             "SCRIPT_NAME": self.script_name,
-            "PATH_INFO": unquote(path.decode("ascii")),
-            "QUERY_STRING": query.decode("ascii"),
-            "SERVER_NAME": host.decode("ascii"),
+            "PATH_INFO": request.url.path,
+            "QUERY_STRING": request.url.query.decode("ascii"),
+            "SERVER_NAME": request.url.host,
             "SERVER_PORT": str(port),
+            "SERVER_PROTOCOL": "HTTP/1.1",
             "REMOTE_ADDR": self.remote_addr,
         }
-        for header_key, header_value in headers:
+        for header_key, header_value in request.headers.raw:
             key = header_key.decode("ascii").upper().replace("-", "_")
             if key not in ("CONTENT_TYPE", "CONTENT_LENGTH"):
                 key = "HTTP_" + key
@@ -112,12 +118,15 @@ def handle_request(
         seen_exc_info = None
 
         def start_response(
-            status: str, response_headers: list, exc_info: typing.Any = None
-        ) -> None:
+            status: str,
+            response_headers: list[tuple[str, str]],
+            exc_info: OptExcInfo | None = None,
+        ) -> typing.Callable[[bytes], typing.Any]:
             nonlocal seen_status, seen_response_headers, seen_exc_info
             seen_status = status
             seen_response_headers = response_headers
             seen_exc_info = exc_info
+            return lambda _: None
 
         result = self.app(environ, start_response)
 
@@ -125,7 +134,7 @@ def start_response(
 
         assert seen_status is not None
         assert seen_response_headers is not None
-        if seen_exc_info and self.raise_app_exceptions:
+        if seen_exc_info and seen_exc_info[0] and self.raise_app_exceptions:
             raise seen_exc_info[1]
 
         status_code = int(seen_status.split()[0])
@@ -133,6 +142,5 @@ def start_response(
             (key.encode("ascii"), value.encode("ascii"))
             for key, value in seen_response_headers
         ]
-        extensions = {}
 
-        return (status_code, headers, stream, extensions)
+        return Response(status_code, headers=headers, stream=stream)
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_types.py b/addon/globalPlugins/spellcheck/libs/httpx/_types.py
index 2381996..649d101 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_types.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_types.py
@@ -7,12 +7,17 @@
 from typing import (
     IO,
     TYPE_CHECKING,
+    Any,
     AsyncIterable,
+    AsyncIterator,
     Callable,
     Dict,
     Iterable,
+    Iterator,
     List,
     Mapping,
+    MutableMapping,
+    NamedTuple,
     Optional,
     Sequence,
     Tuple,
@@ -22,12 +27,21 @@
 if TYPE_CHECKING:  # pragma: no cover
     from ._auth import Auth  # noqa: F401
     from ._config import Proxy, Timeout  # noqa: F401
-    from ._models import URL, Cookies, Headers, QueryParams, Request  # noqa: F401
+    from ._models import Cookies, Headers, Request  # noqa: F401
+    from ._urls import URL, QueryParams  # noqa: F401
 
 
 PrimitiveData = Optional[Union[str, int, float, bool]]
 
-RawURL = Tuple[bytes, bytes, Optional[int], bytes]
+RawURL = NamedTuple(
+    "RawURL",
+    [
+        ("raw_scheme", bytes),
+        ("raw_host", bytes),
+        ("port", Optional[int]),
+        ("raw_path", bytes),
+    ],
+)
 
 URLTypes = Union["URL", str]
 
@@ -38,13 +52,12 @@
     Tuple[Tuple[str, PrimitiveData], ...],
     str,
     bytes,
-    None,
 ]
 
 HeaderTypes = Union[
     "Headers",
-    Dict[str, str],
-    Dict[bytes, bytes],
+    Mapping[str, str],
+    Mapping[bytes, bytes],
     Sequence[Tuple[str, str]],
     Sequence[Tuple[bytes, bytes]],
 ]
@@ -65,27 +78,57 @@
     Tuple[Optional[float], Optional[float], Optional[float], Optional[float]],
     "Timeout",
 ]
-ProxiesTypes = Union[URLTypes, "Proxy", Dict[URLTypes, Union[None, URLTypes, "Proxy"]]]
+ProxyTypes = Union[URLTypes, "Proxy"]
+ProxiesTypes = Union[ProxyTypes, Dict[URLTypes, Union[None, ProxyTypes]]]
 
 AuthTypes = Union[
     Tuple[Union[str, bytes], Union[str, bytes]],
     Callable[["Request"], "Request"],
     "Auth",
-    None,
 ]
 
 RequestContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
 ResponseContent = Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
+ResponseExtensions = MutableMapping[str, Any]
 
-RequestData = dict
+RequestData = Mapping[str, Any]
 
-FileContent = Union[IO[bytes], bytes]
+FileContent = Union[IO[bytes], bytes, str]
 FileTypes = Union[
-    # file (or text)
+    # file (or bytes)
     FileContent,
-    # (filename, file (or text))
+    # (filename, file (or bytes))
     Tuple[Optional[str], FileContent],
-    # (filename, file (or text), content_type)
+    # (filename, file (or bytes), content_type)
     Tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
 ]
 RequestFiles = Union[Mapping[str, FileTypes], Sequence[Tuple[str, FileTypes]]]
+
+RequestExtensions = MutableMapping[str, Any]
+
+
+class SyncByteStream:
+    def __iter__(self) -> Iterator[bytes]:
+        raise NotImplementedError(
+            "The '__iter__' method must be implemented."
+        )  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    def close(self) -> None:
+        """
+        Subclasses can override this method to release any network resources
+        after a request/response cycle is complete.
+        """
+
+
+class AsyncByteStream:
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise NotImplementedError(
+            "The '__aiter__' method must be implemented."
+        )  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_urlparse.py b/addon/globalPlugins/spellcheck/libs/httpx/_urlparse.py
new file mode 100644
index 0000000..6a4b55b
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_urlparse.py
@@ -0,0 +1,502 @@
+"""
+An implementation of `urlparse` that provides URL validation and normalization
+as described by RFC3986.
+
+We rely on this implementation rather than the one in Python's stdlib, because:
+
+* It provides more complete URL validation.
+* It properly differentiates between an empty querystring and an absent querystring,
+  to distinguish URLs with a trailing '?'.
+* It handles scheme, hostname, port, and path normalization.
+* It supports IDNA hostnames, normalizing them to their encoded form.
+* The API supports passing individual components, as well as the complete URL string.
+
+Previously we relied on the excellent `rfc3986` package to handle URL parsing and
+validation, but this module provides a simpler alternative, with less indirection
+required.
+"""
+from __future__ import annotations
+
+import ipaddress
+import re
+import typing
+
+import idna
+
+from ._exceptions import InvalidURL
+
+MAX_URL_LENGTH = 65536
+
+# https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.3
+UNRESERVED_CHARACTERS = (
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+)
+SUB_DELIMS = "!$&'()*+,;="
+
+PERCENT_ENCODED_REGEX = re.compile("%[A-Fa-f0-9]{2}")
+
+
+# {scheme}:      (optional)
+# //{authority}  (optional)
+# {path}
+# ?{query}       (optional)
+# #{fragment}    (optional)
+URL_REGEX = re.compile(
+    (
+        r"(?:(?P<scheme>{scheme}):)?"
+        r"(?://(?P<authority>{authority}))?"
+        r"(?P<path>{path})"
+        r"(?:\?(?P<query>{query}))?"
+        r"(?:#(?P<fragment>{fragment}))?"
+    ).format(
+        scheme="([a-zA-Z][a-zA-Z0-9+.-]*)?",
+        authority="[^/?#]*",
+        path="[^?#]*",
+        query="[^#]*",
+        fragment=".*",
+    )
+)
+
+# {userinfo}@    (optional)
+# {host}
+# :{port}        (optional)
+AUTHORITY_REGEX = re.compile(
+    (
+        r"(?:(?P<userinfo>{userinfo})@)?" r"(?P<host>{host})" r":?(?P<port>{port})?"
+    ).format(
+        userinfo=".*",  # Any character sequence.
+        host="(\\[.*\\]|[^:@]*)",  # Either any character sequence excluding ':' or '@',
+        # or an IPv6 address enclosed within square brackets.
+        port=".*",  # Any character sequence.
+    )
+)
+
+
+# If we call urlparse with an individual component, then we need to regex
+# validate that component individually.
+# Note that we're duplicating the same strings as above. Shock! Horror!!
+COMPONENT_REGEX = {
+    "scheme": re.compile("([a-zA-Z][a-zA-Z0-9+.-]*)?"),
+    "authority": re.compile("[^/?#]*"),
+    "path": re.compile("[^?#]*"),
+    "query": re.compile("[^#]*"),
+    "fragment": re.compile(".*"),
+    "userinfo": re.compile("[^@]*"),
+    "host": re.compile("(\\[.*\\]|[^:]*)"),
+    "port": re.compile(".*"),
+}
+
+
+# We use these simple regexs as a first pass before handing off to
+# the stdlib 'ipaddress' module for IP address validation.
+IPv4_STYLE_HOSTNAME = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$")
+IPv6_STYLE_HOSTNAME = re.compile(r"^\[.*\]$")
+
+
+class ParseResult(typing.NamedTuple):
+    scheme: str
+    userinfo: str
+    host: str
+    port: int | None
+    path: str
+    query: str | None
+    fragment: str | None
+
+    @property
+    def authority(self) -> str:
+        return "".join(
+            [
+                f"{self.userinfo}@" if self.userinfo else "",
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    @property
+    def netloc(self) -> str:
+        return "".join(
+            [
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    def copy_with(self, **kwargs: str | None) -> ParseResult:
+        if not kwargs:
+            return self
+
+        defaults = {
+            "scheme": self.scheme,
+            "authority": self.authority,
+            "path": self.path,
+            "query": self.query,
+            "fragment": self.fragment,
+        }
+        defaults.update(kwargs)
+        return urlparse("", **defaults)
+
+    def __str__(self) -> str:
+        authority = self.authority
+        return "".join(
+            [
+                f"{self.scheme}:" if self.scheme else "",
+                f"//{authority}" if authority else "",
+                self.path,
+                f"?{self.query}" if self.query is not None else "",
+                f"#{self.fragment}" if self.fragment is not None else "",
+            ]
+        )
+
+
+def urlparse(url: str = "", **kwargs: str | None) -> ParseResult:
+    # Initial basic checks on allowable URLs.
+    # ---------------------------------------
+
+    # Hard limit the maximum allowable URL length.
+    if len(url) > MAX_URL_LENGTH:
+        raise InvalidURL("URL too long")
+
+    # If a URL includes any ASCII control characters including \t, \r, \n,
+    # then treat it as invalid.
+    if any(char.isascii() and not char.isprintable() for char in url):
+        raise InvalidURL("Invalid non-printable ASCII character in URL")
+
+    # Some keyword arguments require special handling.
+    # ------------------------------------------------
+
+    # Coerce "port" to a string, if it is provided as an integer.
+    if "port" in kwargs:
+        port = kwargs["port"]
+        kwargs["port"] = str(port) if isinstance(port, int) else port
+
+    # Replace "netloc" with "host and "port".
+    if "netloc" in kwargs:
+        netloc = kwargs.pop("netloc") or ""
+        kwargs["host"], _, kwargs["port"] = netloc.partition(":")
+
+    # Replace "username" and/or "password" with "userinfo".
+    if "username" in kwargs or "password" in kwargs:
+        username = quote(kwargs.pop("username", "") or "")
+        password = quote(kwargs.pop("password", "") or "")
+        kwargs["userinfo"] = f"{username}:{password}" if password else username
+
+    # Replace "raw_path" with "path" and "query".
+    if "raw_path" in kwargs:
+        raw_path = kwargs.pop("raw_path") or ""
+        kwargs["path"], seperator, kwargs["query"] = raw_path.partition("?")
+        if not seperator:
+            kwargs["query"] = None
+
+    # Ensure that IPv6 "host" addresses are always escaped with "[...]".
+    if "host" in kwargs:
+        host = kwargs.get("host") or ""
+        if ":" in host and not (host.startswith("[") and host.endswith("]")):
+            kwargs["host"] = f"[{host}]"
+
+    # If any keyword arguments are provided, ensure they are valid.
+    # -------------------------------------------------------------
+
+    for key, value in kwargs.items():
+        if value is not None:
+            if len(value) > MAX_URL_LENGTH:
+                raise InvalidURL(f"URL component '{key}' too long")
+
+            # If a component includes any ASCII control characters including \t, \r, \n,
+            # then treat it as invalid.
+            if any(char.isascii() and not char.isprintable() for char in value):
+                raise InvalidURL(
+                    f"Invalid non-printable ASCII character in URL component '{key}'"
+                )
+
+            # Ensure that keyword arguments match as a valid regex.
+            if not COMPONENT_REGEX[key].fullmatch(value):
+                raise InvalidURL(f"Invalid URL component '{key}'")
+
+    # The URL_REGEX will always match, but may have empty components.
+    url_match = URL_REGEX.match(url)
+    assert url_match is not None
+    url_dict = url_match.groupdict()
+
+    # * 'scheme', 'authority', and 'path' may be empty strings.
+    # * 'query' may be 'None', indicating no trailing "?" portion.
+    #   Any string including the empty string, indicates a trailing "?".
+    # * 'fragment' may be 'None', indicating no trailing "#" portion.
+    #   Any string including the empty string, indicates a trailing "#".
+    scheme = kwargs.get("scheme", url_dict["scheme"]) or ""
+    authority = kwargs.get("authority", url_dict["authority"]) or ""
+    path = kwargs.get("path", url_dict["path"]) or ""
+    query = kwargs.get("query", url_dict["query"])
+    fragment = kwargs.get("fragment", url_dict["fragment"])
+
+    # The AUTHORITY_REGEX will always match, but may have empty components.
+    authority_match = AUTHORITY_REGEX.match(authority)
+    assert authority_match is not None
+    authority_dict = authority_match.groupdict()
+
+    # * 'userinfo' and 'host' may be empty strings.
+    # * 'port' may be 'None'.
+    userinfo = kwargs.get("userinfo", authority_dict["userinfo"]) or ""
+    host = kwargs.get("host", authority_dict["host"]) or ""
+    port = kwargs.get("port", authority_dict["port"])
+
+    # Normalize and validate each component.
+    # We end up with a parsed representation of the URL,
+    # with components that are plain ASCII bytestrings.
+    parsed_scheme: str = scheme.lower()
+    parsed_userinfo: str = quote(userinfo, safe=SUB_DELIMS + ":")
+    parsed_host: str = encode_host(host)
+    parsed_port: int | None = normalize_port(port, scheme)
+
+    has_scheme = parsed_scheme != ""
+    has_authority = (
+        parsed_userinfo != "" or parsed_host != "" or parsed_port is not None
+    )
+    validate_path(path, has_scheme=has_scheme, has_authority=has_authority)
+    if has_authority:
+        path = normalize_path(path)
+
+    # The GEN_DELIMS set is... : / ? # [ ] @
+    # These do not need to be percent-quoted unless they serve as delimiters for the
+    # specific component.
+
+    # For 'path' we need to drop ? and # from the GEN_DELIMS set.
+    parsed_path: str = quote(path, safe=SUB_DELIMS + ":/[]@")
+    # For 'query' we need to drop '#' from the GEN_DELIMS set.
+    parsed_query: str | None = (
+        None if query is None else quote(query, safe=SUB_DELIMS + ":/?[]@")
+    )
+    # For 'fragment' we can include all of the GEN_DELIMS set.
+    parsed_fragment: str | None = (
+        None if fragment is None else quote(fragment, safe=SUB_DELIMS + ":/?#[]@")
+    )
+
+    # The parsed ASCII bytestrings are our canonical form.
+    # All properties of the URL are derived from these.
+    return ParseResult(
+        parsed_scheme,
+        parsed_userinfo,
+        parsed_host,
+        parsed_port,
+        parsed_path,
+        parsed_query,
+        parsed_fragment,
+    )
+
+
+def encode_host(host: str) -> str:
+    if not host:
+        return ""
+
+    elif IPv4_STYLE_HOSTNAME.match(host):
+        # Validate IPv4 hostnames like #.#.#.#
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+        try:
+            ipaddress.IPv4Address(host)
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv4 address: {host!r}")
+        return host
+
+    elif IPv6_STYLE_HOSTNAME.match(host):
+        # Validate IPv6 hostnames like [...]
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # "A host identified by an Internet Protocol literal address, version 6
+        # [RFC3513] or later, is distinguished by enclosing the IP literal
+        # within square brackets ("[" and "]").  This is the only place where
+        # square bracket characters are allowed in the URI syntax."
+        try:
+            ipaddress.IPv6Address(host[1:-1])
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv6 address: {host!r}")
+        return host[1:-1]
+
+    elif host.isascii():
+        # Regular ASCII hostnames
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # reg-name    = *( unreserved / pct-encoded / sub-delims )
+        return quote(host.lower(), safe=SUB_DELIMS)
+
+    # IDNA hostnames
+    try:
+        return idna.encode(host.lower()).decode("ascii")
+    except idna.IDNAError:
+        raise InvalidURL(f"Invalid IDNA hostname: {host!r}")
+
+
+def normalize_port(port: str | int | None, scheme: str) -> int | None:
+    # From https://tools.ietf.org/html/rfc3986#section-3.2.3
+    #
+    # "A scheme may define a default port.  For example, the "http" scheme
+    # defines a default port of "80", corresponding to its reserved TCP
+    # port number.  The type of port designated by the port number (e.g.,
+    # TCP, UDP, SCTP) is defined by the URI scheme.  URI producers and
+    # normalizers should omit the port component and its ":" delimiter if
+    # port is empty or if its value would be the same as that of the
+    # scheme's default."
+    if port is None or port == "":
+        return None
+
+    try:
+        port_as_int = int(port)
+    except ValueError:
+        raise InvalidURL(f"Invalid port: {port!r}")
+
+    # See https://url.spec.whatwg.org/#url-miscellaneous
+    default_port = {"ftp": 21, "http": 80, "https": 443, "ws": 80, "wss": 443}.get(
+        scheme
+    )
+    if port_as_int == default_port:
+        return None
+    return port_as_int
+
+
+def validate_path(path: str, has_scheme: bool, has_authority: bool) -> None:
+    """
+    Path validation rules that depend on if the URL contains
+    a scheme or authority component.
+
+    See https://datatracker.ietf.org/doc/html/rfc3986.html#section-3.3
+    """
+    if has_authority:
+        # If a URI contains an authority component, then the path component
+        # must either be empty or begin with a slash ("/") character."
+        if path and not path.startswith("/"):
+            raise InvalidURL("For absolute URLs, path must be empty or begin with '/'")
+    else:
+        # If a URI does not contain an authority component, then the path cannot begin
+        # with two slash characters ("//").
+        if path.startswith("//"):
+            raise InvalidURL(
+                "URLs with no authority component cannot have a path starting with '//'"
+            )
+        # In addition, a URI reference (Section 4.1) may be a relative-path reference,
+        # in which case the first path segment cannot contain a colon (":") character.
+        if path.startswith(":") and not has_scheme:
+            raise InvalidURL(
+                "URLs with no scheme component cannot have a path starting with ':'"
+            )
+
+
+def normalize_path(path: str) -> str:
+    """
+    Drop "." and ".." segments from a URL path.
+
+    For example:
+
+        normalize_path("/path/./to/somewhere/..") == "/path/to"
+    """
+    # https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    components = path.split("/")
+    output: list[str] = []
+    for component in components:
+        if component == ".":
+            pass
+        elif component == "..":
+            if output and output != [""]:
+                output.pop()
+        else:
+            output.append(component)
+    return "/".join(output)
+
+
+def percent_encode(char: str) -> str:
+    """
+    Replace a single character with the percent-encoded representation.
+
+    Characters outside the ASCII range are represented with their a percent-encoded
+    representation of their UTF-8 byte sequence.
+
+    For example:
+
+        percent_encode(" ") == "%20"
+    """
+    return "".join([f"%{byte:02x}" for byte in char.encode("utf-8")]).upper()
+
+
+def is_safe(string: str, safe: str = "/") -> bool:
+    """
+    Determine if a given string is already quote-safe.
+    """
+    NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe + "%"
+
+    # All characters must already be non-escaping or '%'
+    for char in string:
+        if char not in NON_ESCAPED_CHARS:
+            return False
+
+    return True
+
+
+def percent_encoded(string: str, safe: str = "/") -> str:
+    """
+    Use percent-encoding to quote a string.
+    """
+    if is_safe(string, safe=safe):
+        return string
+
+    NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe
+    return "".join(
+        [char if char in NON_ESCAPED_CHARS else percent_encode(char) for char in string]
+    )
+
+
+def quote(string: str, safe: str = "/") -> str:
+    """
+    Use percent-encoding to quote a string, omitting existing '%xx' escape sequences.
+
+    See: https://www.rfc-editor.org/rfc/rfc3986#section-2.1
+
+    * `string`: The string to be percent-escaped.
+    * `safe`: A string containing characters that may be treated as safe, and do not
+        need to be escaped. Unreserved characters are always treated as safe.
+        See: https://www.rfc-editor.org/rfc/rfc3986#section-2.3
+    """
+    parts = []
+    current_position = 0
+    for match in re.finditer(PERCENT_ENCODED_REGEX, string):
+        start_position, end_position = match.start(), match.end()
+        matched_text = match.group(0)
+        # Add any text up to the '%xx' escape sequence.
+        if start_position != current_position:
+            leading_text = string[current_position:start_position]
+            parts.append(percent_encoded(leading_text, safe=safe))
+
+        # Add the '%xx' escape sequence.
+        parts.append(matched_text)
+        current_position = end_position
+
+    # Add any text after the final '%xx' escape sequence.
+    if current_position != len(string):
+        trailing_text = string[current_position:]
+        parts.append(percent_encoded(trailing_text, safe=safe))
+
+    return "".join(parts)
+
+
+def urlencode(items: list[tuple[str, str]]) -> str:
+    """
+    We can use a much simpler version of the stdlib urlencode here because
+    we don't need to handle a bunch of different typing cases, such as bytes vs str.
+
+    https://github.com/python/cpython/blob/b2f7b2ef0b5421e01efb8c7bee2ef95d3bab77eb/Lib/urllib/parse.py#L926
+
+    Note that we use '%20' encoding for spaces. and '%2F  for '/'.
+    This is slightly different than `requests`, but is the behaviour that browsers use.
+
+    See
+    - https://github.com/encode/httpx/issues/2536
+    - https://github.com/encode/httpx/issues/2721
+    - https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urlencode
+    """
+    return "&".join(
+        [
+            percent_encoded(k, safe="") + "=" + percent_encoded(v, safe="")
+            for k, v in items
+        ]
+    )
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_urls.py b/addon/globalPlugins/spellcheck/libs/httpx/_urls.py
new file mode 100644
index 0000000..43dedd5
--- /dev/null
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_urls.py
@@ -0,0 +1,646 @@
+from __future__ import annotations
+
+import typing
+from urllib.parse import parse_qs, unquote
+
+import idna
+
+from ._types import QueryParamTypes, RawURL, URLTypes
+from ._urlparse import urlencode, urlparse
+from ._utils import primitive_value_to_str
+
+
+class URL:
+    """
+    url = httpx.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
+
+    assert url.scheme == "https"
+    assert url.username == "jo@email.com"
+    assert url.password == "a secret"
+    assert url.userinfo == b"jo%40email.com:a%20secret"
+    assert url.host == "müller.de"
+    assert url.raw_host == b"xn--mller-kva.de"
+    assert url.port == 1234
+    assert url.netloc == b"xn--mller-kva.de:1234"
+    assert url.path == "/pa th"
+    assert url.query == b"?search=ab"
+    assert url.raw_path == b"/pa%20th?search=ab"
+    assert url.fragment == "anchorlink"
+
+    The components of a URL are broken down like this:
+
+       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
+    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
+               [       userinfo        ] [   netloc   ][    raw_path    ]
+
+    Note that:
+
+    * `url.scheme` is normalized to always be lowercased.
+
+    * `url.host` is normalized to always be lowercased. Internationalized domain
+      names are represented in unicode, without IDNA encoding applied. For instance:
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.host == "中国.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.host == "中国.icom.museum"
+
+    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+    * `url.port` is either None or an integer. URLs that include the default port for
+      "http", "https", "ws", "wss", and "ftp" schemes have their port
+      normalized to `None`.
+
+      assert httpx.URL("http://example.com") == httpx.URL("http://example.com:80")
+      assert httpx.URL("http://example.com").port is None
+      assert httpx.URL("http://example.com:80").port is None
+
+    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work
+      with `url.username` and `url.password` instead, which handle the URL escaping.
+
+    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
+      This portion is used as the target when constructing HTTP requests. Usually you'll
+      want to work with `url.path` instead.
+
+    * `url.query` is raw bytes, without URL escaping. A URL query string portion can
+      only be properly URL escaped when decoding the parameter names and values
+      themselves.
+    """
+
+    def __init__(self, url: URL | str = "", **kwargs: typing.Any) -> None:
+        if kwargs:
+            allowed = {
+                "scheme": str,
+                "username": str,
+                "password": str,
+                "userinfo": bytes,
+                "host": str,
+                "port": int,
+                "netloc": bytes,
+                "path": str,
+                "query": bytes,
+                "raw_path": bytes,
+                "fragment": str,
+                "params": object,
+            }
+
+            # Perform type checking for all supported keyword arguments.
+            for key, value in kwargs.items():
+                if key not in allowed:
+                    message = f"{key!r} is an invalid keyword argument for URL()"
+                    raise TypeError(message)
+                if value is not None and not isinstance(value, allowed[key]):
+                    expected = allowed[key].__name__
+                    seen = type(value).__name__
+                    message = f"Argument {key!r} must be {expected} but got {seen}"
+                    raise TypeError(message)
+                if isinstance(value, bytes):
+                    kwargs[key] = value.decode("ascii")
+
+            if "params" in kwargs:
+                # Replace any "params" keyword with the raw "query" instead.
+                #
+                # Ensure that empty params use `kwargs["query"] = None` rather
+                # than `kwargs["query"] = ""`, so that generated URLs do not
+                # include an empty trailing "?".
+                params = kwargs.pop("params")
+                kwargs["query"] = None if not params else str(QueryParams(params))
+
+        if isinstance(url, str):
+            self._uri_reference = urlparse(url, **kwargs)
+        elif isinstance(url, URL):
+            self._uri_reference = url._uri_reference.copy_with(**kwargs)
+        else:
+            raise TypeError(
+                "Invalid type for url.  Expected str or httpx.URL,"
+                f" got {type(url)}: {url!r}"
+            )
+
+    @property
+    def scheme(self) -> str:
+        """
+        The URL scheme, such as "http", "https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme
+
+    @property
+    def raw_scheme(self) -> bytes:
+        """
+        The raw bytes representation of the URL scheme, such as b"http", b"https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme.encode("ascii")
+
+    @property
+    def userinfo(self) -> bytes:
+        """
+        The URL userinfo as a raw bytestring.
+        For example: b"jo%40email.com:a%20secret".
+        """
+        return self._uri_reference.userinfo.encode("ascii")
+
+    @property
+    def username(self) -> str:
+        """
+        The URL username as a string, with URL decoding applied.
+        For example: "jo@email.com"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[0])
+
+    @property
+    def password(self) -> str:
+        """
+        The URL password as a string, with URL decoding applied.
+        For example: "a secret"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[2])
+
+    @property
+    def host(self) -> str:
+        """
+        The URL host as a string.
+        Always normalized to lowercase, with IDNA hosts decoded into unicode.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.host == "www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.host == "::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host
+
+        if host.startswith("xn--"):
+            host = idna.decode(host)
+
+        return host
+
+    @property
+    def raw_host(self) -> bytes:
+        """
+        The raw bytes representation of the URL host.
+        Always normalized to lowercase, and IDNA encoded.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.raw_host == b"www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.raw_host == b"::ffff:192.168.0.1"
+        """
+        return self._uri_reference.host.encode("ascii")
+
+    @property
+    def port(self) -> int | None:
+        """
+        The URL port as an integer.
+
+        Note that the URL class performs port normalization as per the WHATWG spec.
+        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
+        treated as `None`.
+
+        For example:
+
+        assert httpx.URL("http://www.example.com") == httpx.URL("http://www.example.com:80")
+        assert httpx.URL("http://www.example.com:80").port is None
+        """
+        return self._uri_reference.port
+
+    @property
+    def netloc(self) -> bytes:
+        """
+        Either `<host>` or `<host>:<port>` as bytes.
+        Always normalized to lowercase, and IDNA encoded.
+
+        This property may be used for generating the value of a request
+        "Host" header.
+        """
+        return self._uri_reference.netloc.encode("ascii")
+
+    @property
+    def path(self) -> str:
+        """
+        The URL path as a string. Excluding the query string, and URL decoded.
+
+        For example:
+
+        url = httpx.URL("https://example.com/pa%20th")
+        assert url.path == "/pa th"
+        """
+        path = self._uri_reference.path or "/"
+        return unquote(path)
+
+    @property
+    def query(self) -> bytes:
+        """
+        The URL query string, as raw bytes, excluding the leading b"?".
+
+        This is necessarily a bytewise interface, because we cannot
+        perform URL decoding of this representation until we've parsed
+        the keys and values into a QueryParams instance.
+
+        For example:
+
+        url = httpx.URL("https://example.com/?filter=some%20search%20terms")
+        assert url.query == b"filter=some%20search%20terms"
+        """
+        query = self._uri_reference.query or ""
+        return query.encode("ascii")
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        The URL query parameters, neatly parsed and packaged into an immutable
+        multidict representation.
+        """
+        return QueryParams(self._uri_reference.query)
+
+    @property
+    def raw_path(self) -> bytes:
+        """
+        The complete URL path and query string as raw bytes.
+        Used as the target when constructing HTTP requests.
+
+        For example:
+
+        GET /users?search=some%20text HTTP/1.1
+        Host: www.example.org
+        Connection: close
+        """
+        path = self._uri_reference.path or "/"
+        if self._uri_reference.query is not None:
+            path += "?" + self._uri_reference.query
+        return path.encode("ascii")
+
+    @property
+    def fragment(self) -> str:
+        """
+        The URL fragments, as used in HTML anchors.
+        As a string, without the leading '#'.
+        """
+        return unquote(self._uri_reference.fragment or "")
+
+    @property
+    def raw(self) -> RawURL:
+        """
+        Provides the (scheme, host, port, target) for the outgoing request.
+
+        In older versions of `httpx` this was used in the low-level transport API.
+        We no longer use `RawURL`, and this property will be deprecated
+        in a future release.
+        """
+        return RawURL(
+            self.raw_scheme,
+            self.raw_host,
+            self.port,
+            self.raw_path,
+        )
+
+    @property
+    def is_absolute_url(self) -> bool:
+        """
+        Return `True` for absolute URLs such as 'http://example.com/path',
+        and `False` for relative URLs such as '/path'.
+        """
+        # We don't use `.is_absolute` from `rfc3986` because it treats
+        # URLs with a fragment portion as not absolute.
+        # What we actually care about is if the URL provides
+        # a scheme and hostname to which connections should be made.
+        return bool(self._uri_reference.scheme and self._uri_reference.host)
+
+    @property
+    def is_relative_url(self) -> bool:
+        """
+        Return `False` for absolute URLs such as 'http://example.com/path',
+        and `True` for relative URLs such as '/path'.
+        """
+        return not self.is_absolute_url
+
+    def copy_with(self, **kwargs: typing.Any) -> URL:
+        """
+        Copy this URL, returning a new URL with some components altered.
+        Accepts the same set of parameters as the components that are made
+        available via properties on the `URL` class.
+
+        For example:
+
+        url = httpx.URL("https://www.example.com").copy_with(
+            username="jo@gmail.com", password="a secret"
+        )
+        assert url == "https://jo%40email.com:a%20secret@www.example.com"
+        """
+        return URL(self, **kwargs)
+
+    def copy_set_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.set(key, value))
+
+    def copy_add_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.add(key, value))
+
+    def copy_remove_param(self, key: str) -> URL:
+        return self.copy_with(params=self.params.remove(key))
+
+    def copy_merge_params(self, params: QueryParamTypes) -> URL:
+        return self.copy_with(params=self.params.merge(params))
+
+    def join(self, url: URLTypes) -> URL:
+        """
+        Return an absolute URL, using this URL as the base.
+
+        Eg.
+
+        url = httpx.URL("https://www.example.com/test")
+        url = url.join("/new/path")
+        assert url == "https://www.example.com/new/path"
+        """
+        from urllib.parse import urljoin
+
+        return URL(urljoin(str(self), str(URL(url))))
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
+
+    def __str__(self) -> str:
+        return str(self._uri_reference)
+
+    def __repr__(self) -> str:
+        scheme, userinfo, host, port, path, query, fragment = self._uri_reference
+
+        if ":" in userinfo:
+            # Mask any password component.
+            userinfo = f'{userinfo.split(":")[0]}:[secure]'
+
+        authority = "".join(
+            [
+                f"{userinfo}@" if userinfo else "",
+                f"[{host}]" if ":" in host else host,
+                f":{port}" if port is not None else "",
+            ]
+        )
+        url = "".join(
+            [
+                f"{self.scheme}:" if scheme else "",
+                f"//{authority}" if authority else "",
+                path,
+                f"?{query}" if query is not None else "",
+                f"#{fragment}" if fragment is not None else "",
+            ]
+        )
+
+        return f"{self.__class__.__name__}({url!r})"
+
+
+class QueryParams(typing.Mapping[str, str]):
+    """
+    URL query parameters, as a multi-dict.
+    """
+
+    def __init__(self, *args: QueryParamTypes | None, **kwargs: typing.Any) -> None:
+        assert len(args) < 2, "Too many arguments."
+        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
+
+        value = args[0] if args else kwargs
+
+        if value is None or isinstance(value, (str, bytes)):
+            value = value.decode("ascii") if isinstance(value, bytes) else value
+            self._dict = parse_qs(value, keep_blank_values=True)
+        elif isinstance(value, QueryParams):
+            self._dict = {k: list(v) for k, v in value._dict.items()}
+        else:
+            dict_value: dict[typing.Any, list[typing.Any]] = {}
+            if isinstance(value, (list, tuple)):
+                # Convert list inputs like:
+                #     [("a", "123"), ("a", "456"), ("b", "789")]
+                # To a dict representation, like:
+                #     {"a": ["123", "456"], "b": ["789"]}
+                for item in value:
+                    dict_value.setdefault(item[0], []).append(item[1])
+            else:
+                # Convert dict inputs like:
+                #    {"a": "123", "b": ["456", "789"]}
+                # To dict inputs where values are always lists, like:
+                #    {"a": ["123"], "b": ["456", "789"]}
+                dict_value = {
+                    k: list(v) if isinstance(v, (list, tuple)) else [v]
+                    for k, v in value.items()
+                }
+
+            # Ensure that keys and values are neatly coerced to strings.
+            # We coerce values `True` and `False` to JSON-like "true" and "false"
+            # representations, and coerce `None` values to the empty string.
+            self._dict = {
+                str(k): [primitive_value_to_str(item) for item in v]
+                for k, v in dict_value.items()
+            }
+
+    def keys(self) -> typing.KeysView[str]:
+        """
+        Return all the keys in the query params.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.keys()) == ["a", "b"]
+        """
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        """
+        Return all the values in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.values()) == ["123", "789"]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return all items in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.items()) == [("a", "123"), ("b", "789")]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return all items in the query params. Allow duplicate keys to occur.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
+        """
+        multi_items: list[tuple[str, str]] = []
+        for k, v in self._dict.items():
+            multi_items.extend([(k, i) for i in v])
+        return multi_items
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        """
+        Get a value from the query param for a given key. If the key occurs
+        more than once, then only the first value is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get("a") == "123"
+        """
+        if key in self._dict:
+            return self._dict[str(key)][0]
+        return default
+
+    def get_list(self, key: str) -> list[str]:
+        """
+        Get all values from the query param for a given key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get_list("a") == ["123", "456"]
+        """
+        return list(self._dict.get(str(key), []))
+
+    def set(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.set("a", "456")
+        assert q == httpx.QueryParams("a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = [primitive_value_to_str(value)]
+        return q
+
+    def add(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting or appending the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.add("a", "456")
+        assert q == httpx.QueryParams("a=123&a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
+        return q
+
+    def remove(self, key: str) -> QueryParams:
+        """
+        Return a new QueryParams instance, removing the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.remove("a")
+        assert q == httpx.QueryParams("")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict.pop(str(key), None)
+        return q
+
+    def merge(self, params: QueryParamTypes | None = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, updated with.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"b": "456"})
+        assert q == httpx.QueryParams("a=123&b=456")
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"a": "456", "b": "789"})
+        assert q == httpx.QueryParams("a=456&b=789")
+        """
+        q = QueryParams(params)
+        q._dict = {**self._dict, **q._dict}
+        return q
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key][0]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        return bool(self._dict)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self.multi_items()) == sorted(other.multi_items())
+
+    def __str__(self) -> str:
+        """
+        Note that we use '%20' encoding for spaces, and treat '/' as a safe
+        character.
+
+        See https://github.com/encode/httpx/issues/2536 and
+        https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urlencode
+        """
+        return urlencode(self.multi_items())
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+    def update(self, params: QueryParamTypes | None = None) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.merge(...)` to create an updated copy."
+        )
+
+    def __setitem__(self, key: str, value: str) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.set(key, value)` to create an updated copy."
+        )
diff --git a/addon/globalPlugins/spellcheck/libs/httpx/_utils.py b/addon/globalPlugins/spellcheck/libs/httpx/_utils.py
index 30ab2ed..a9ece19 100644
--- a/addon/globalPlugins/spellcheck/libs/httpx/_utils.py
+++ b/addon/globalPlugins/spellcheck/libs/httpx/_utils.py
@@ -1,10 +1,11 @@
+from __future__ import annotations
+
 import codecs
-import logging
+import email.message
+import ipaddress
 import mimetypes
-import netrc
 import os
 import re
-import sys
 import time
 import typing
 from pathlib import Path
@@ -15,12 +16,12 @@
 from ._types import PrimitiveData
 
 if typing.TYPE_CHECKING:  # pragma: no cover
-    from ._models import URL
+    from ._urls import URL
 
 
 _HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
 _HTML5_FORM_ENCODING_REPLACEMENTS.update(
-    {chr(c): "%{:02X}".format(c) for c in range(0x00, 0x1F + 1) if c != 0x1B}
+    {chr(c): "%{:02X}".format(c) for c in range(0x1F + 1) if c != 0x1B}
 )
 _HTML5_FORM_ENCODING_RE = re.compile(
     r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()])
@@ -28,9 +29,9 @@
 
 
 def normalize_header_key(
-    value: typing.Union[str, bytes],
+    value: str | bytes,
     lower: bool,
-    encoding: str = None,
+    encoding: str | None = None,
 ) -> bytes:
     """
     Coerce str/bytes into a strictly byte-wise HTTP header key.
@@ -43,9 +44,7 @@ def normalize_header_key(
     return bytes_value.lower() if lower else bytes_value
 
 
-def normalize_header_value(
-    value: typing.Union[str, bytes], encoding: str = None
-) -> bytes:
+def normalize_header_value(value: str | bytes, encoding: str | None = None) -> bytes:
     """
     Coerce str/bytes into a strictly byte-wise HTTP header value.
     """
@@ -54,7 +53,7 @@ def normalize_header_value(
     return value.encode(encoding or "ascii")
 
 
-def primitive_value_to_str(value: "PrimitiveData") -> str:
+def primitive_value_to_str(value: PrimitiveData) -> str:
     """
     Coerce a primitive data type into a string value.
 
@@ -80,12 +79,10 @@ def is_known_encoding(encoding: str) -> bool:
     return True
 
 
-def format_form_param(name: str, value: typing.Union[str, bytes]) -> bytes:
+def format_form_param(name: str, value: str) -> bytes:
     """
     Encode a name/value pair within a multipart form.
     """
-    if isinstance(value, bytes):
-        value = value.decode()
 
     def replacer(match: typing.Match[str]) -> str:
         return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
@@ -94,73 +91,7 @@ def replacer(match: typing.Match[str]) -> str:
     return f'{name}="{value}"'.encode()
 
 
-# Null bytes; no need to recreate these on each call to guess_json_utf
-_null = b"\x00"
-_null2 = _null * 2
-_null3 = _null * 3
-
-
-def guess_json_utf(data: bytes) -> typing.Optional[str]:
-    # JSON always starts with two ASCII characters, so detection is as
-    # easy as counting the nulls and from their location and count
-    # determine the encoding. Also detect a BOM, if present.
-    sample = data[:4]
-    if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE):
-        return "utf-32"  # BOM included
-    if sample[:3] == codecs.BOM_UTF8:
-        return "utf-8-sig"  # BOM included, MS style (discouraged)
-    if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE):
-        return "utf-16"  # BOM included
-    nullcount = sample.count(_null)
-    if nullcount == 0:
-        return "utf-8"
-    if nullcount == 2:
-        if sample[::2] == _null2:  # 1st and 3rd are null
-            return "utf-16-be"
-        if sample[1::2] == _null2:  # 2nd and 4th are null
-            return "utf-16-le"
-        # Did not detect 2 valid UTF-16 ascii-range characters
-    if nullcount == 3:
-        if sample[:3] == _null3:
-            return "utf-32-be"
-        if sample[1:] == _null3:
-            return "utf-32-le"
-        # Did not detect a valid UTF-32 ascii-range character
-    return None
-
-
-class NetRCInfo:
-    def __init__(self, files: typing.Optional[typing.List[str]] = None) -> None:
-        if files is None:
-            files = [os.getenv("NETRC", ""), "~/.netrc", "~/_netrc"]
-        self.netrc_files = files
-
-    @property
-    def netrc_info(self) -> typing.Optional[netrc.netrc]:
-        if not hasattr(self, "_netrc_info"):
-            self._netrc_info = None
-            for file_path in self.netrc_files:
-                expanded_path = Path(file_path).expanduser()
-                try:
-                    if expanded_path.is_file():
-                        self._netrc_info = netrc.netrc(str(expanded_path))
-                        break
-                except (netrc.NetrcParseError, IOError):  # pragma: nocover
-                    # Issue while reading the netrc file, ignore...
-                    pass
-        return self._netrc_info
-
-    def get_credentials(self, host: str) -> typing.Optional[typing.Tuple[str, str]]:
-        if self.netrc_info is None:
-            return None
-
-        auth_info = self.netrc_info.authenticators(host)
-        if auth_info is None or auth_info[2] is None:
-            return None
-        return (auth_info[0], auth_info[2])
-
-
-def get_ca_bundle_from_env() -> typing.Optional[str]:
+def get_ca_bundle_from_env() -> str | None:
     if "SSL_CERT_FILE" in os.environ:
         ssl_file = Path(os.environ["SSL_CERT_FILE"])
         if ssl_file.is_file():
@@ -172,7 +103,7 @@ def get_ca_bundle_from_env() -> typing.Optional[str]:
     return None
 
 
-def parse_header_links(value: str) -> typing.List[typing.Dict[str, str]]:
+def parse_header_links(value: str) -> list[dict[str, str]]:
     """
     Returns a list of parsed link headers, for more info see:
     https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
@@ -188,7 +119,7 @@ def parse_header_links(value: str) -> typing.List[typing.Dict[str, str]]:
     :param value: HTTP Link entity-header field
     :return: list of parsed link headers
     """
-    links: typing.List[typing.Dict[str, str]] = []
+    links: list[dict[str, str]] = []
     replace_chars = " '\""
     value = value.strip(replace_chars)
     if not value:
@@ -209,69 +140,33 @@ def parse_header_links(value: str) -> typing.List[typing.Dict[str, str]]:
     return links
 
 
+def parse_content_type_charset(content_type: str) -> str | None:
+    # We used to use `cgi.parse_header()` here, but `cgi` became a dead battery.
+    # See: https://peps.python.org/pep-0594/#cgi
+    msg = email.message.Message()
+    msg["content-type"] = content_type
+    return msg.get_content_charset(failobj=None)
+
+
 SENSITIVE_HEADERS = {"authorization", "proxy-authorization"}
 
 
 def obfuscate_sensitive_headers(
-    items: typing.Iterable[typing.Tuple[typing.AnyStr, typing.AnyStr]]
-) -> typing.Iterator[typing.Tuple[typing.AnyStr, typing.AnyStr]]:
+    items: typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]],
+) -> typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]:
     for k, v in items:
         if to_str(k.lower()) in SENSITIVE_HEADERS:
             v = to_bytes_or_str("[secure]", match_type_of=v)
         yield k, v
 
 
-_LOGGER_INITIALIZED = False
-TRACE_LOG_LEVEL = 5
-
-
-class Logger(logging.Logger):
-    # Stub for type checkers.
-    def trace(self, message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
-        ...  # pragma: nocover
-
-
-def get_logger(name: str) -> Logger:
-    """
-    Get a `logging.Logger` instance, and optionally
-    set up debug logging based on the HTTPX_LOG_LEVEL environment variable.
-    """
-    global _LOGGER_INITIALIZED
-
-    if not _LOGGER_INITIALIZED:
-        _LOGGER_INITIALIZED = True
-        logging.addLevelName(TRACE_LOG_LEVEL, "TRACE")
-
-        log_level = os.environ.get("HTTPX_LOG_LEVEL", "").upper()
-        if log_level in ("DEBUG", "TRACE"):
-            logger = logging.getLogger("httpx")
-            logger.setLevel(logging.DEBUG if log_level == "DEBUG" else TRACE_LOG_LEVEL)
-            handler = logging.StreamHandler(sys.stderr)
-            handler.setFormatter(
-                logging.Formatter(
-                    fmt="%(levelname)s [%(asctime)s] %(name)s - %(message)s",
-                    datefmt="%Y-%m-%d %H:%M:%S",
-                )
-            )
-            logger.addHandler(handler)
-
-    logger = logging.getLogger(name)
-
-    def trace(message: str, *args: typing.Any, **kwargs: typing.Any) -> None:
-        logger.log(TRACE_LOG_LEVEL, message, *args, **kwargs)
-
-    logger.trace = trace  # type: ignore
-
-    return typing.cast(Logger, logger)
-
-
-def port_or_default(url: "URL") -> typing.Optional[int]:
+def port_or_default(url: URL) -> int | None:
     if url.port is not None:
         return url.port
     return {"http": 80, "https": 443}.get(url.scheme)
 
 
-def same_origin(url: "URL", other: "URL") -> bool:
+def same_origin(url: URL, other: URL) -> bool:
     """
     Return 'True' if the given URLs share the same origin.
     """
@@ -282,7 +177,22 @@ def same_origin(url: "URL", other: "URL") -> bool:
     )
 
 
-def get_environment_proxies() -> typing.Dict[str, typing.Optional[str]]:
+def is_https_redirect(url: URL, location: URL) -> bool:
+    """
+    Return 'True' if 'location' is a HTTPS upgrade of 'url'
+    """
+    if url.host != location.host:
+        return False
+
+    return (
+        url.scheme == "http"
+        and port_or_default(url) == 80
+        and location.scheme == "https"
+        and port_or_default(location) == 443
+    )
+
+
+def get_environment_proxies() -> dict[str, str | None]:
     """Gets proxy information from the environment"""
 
     # urllib.request.getproxies() falls back on System
@@ -290,7 +200,7 @@ def get_environment_proxies() -> typing.Dict[str, typing.Optional[str]]:
     # We don't want to propagate non-HTTP proxies into
     # our configuration such as 'TRAVIS_APT_PROXY'.
     proxy_info = getproxies()
-    mounts: typing.Dict[str, typing.Optional[str]] = {}
+    mounts: dict[str, str | None] = {}
 
     for scheme in ("http", "https", "all"):
         if proxy_info.get(scheme):
@@ -305,7 +215,7 @@ def get_environment_proxies() -> typing.Dict[str, typing.Optional[str]]:
         # on how names in `NO_PROXY` are handled.
         if hostname == "*":
             # If NO_PROXY=* is used or if "*" occurs as any one of the comma
-            # seperated hostnames, then we should just bypass any information
+            # separated hostnames, then we should just bypass any information
             # from HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and always ignore
             # proxies.
             return {}
@@ -315,16 +225,27 @@ def get_environment_proxies() -> typing.Dict[str, typing.Optional[str]]:
             # NO_PROXY=google.com is marked as "all://*google.com,
             #   which disables "www.google.com" and "google.com".
             #   (But not "wwwgoogle.com")
-            mounts[f"all://*{hostname}"] = None
+            # NO_PROXY can include domains, IPv6, IPv4 addresses and "localhost"
+            #   NO_PROXY=example.com,::1,localhost,192.168.0.0/16
+            if "://" in hostname:
+                mounts[hostname] = None
+            elif is_ipv4_hostname(hostname):
+                mounts[f"all://{hostname}"] = None
+            elif is_ipv6_hostname(hostname):
+                mounts[f"all://[{hostname}]"] = None
+            elif hostname.lower() == "localhost":
+                mounts[f"all://{hostname}"] = None
+            else:
+                mounts[f"all://*{hostname}"] = None
 
     return mounts
 
 
-def to_bytes(value: typing.Union[str, bytes], encoding: str = "utf-8") -> bytes:
+def to_bytes(value: str | bytes, encoding: str = "utf-8") -> bytes:
     return value.encode(encoding) if isinstance(value, str) else value
 
 
-def to_str(value: typing.Union[str, bytes], encoding: str = "utf-8") -> str:
+def to_str(value: str | bytes, encoding: str = "utf-8") -> str:
     return value if isinstance(value, str) else value.decode(encoding)
 
 
@@ -336,13 +257,13 @@ def unquote(value: str) -> str:
     return value[1:-1] if value[0] == value[-1] == '"' else value
 
 
-def guess_content_type(filename: typing.Optional[str]) -> typing.Optional[str]:
+def guess_content_type(filename: str | None) -> str | None:
     if filename:
         return mimetypes.guess_type(filename)[0] or "application/octet-stream"
     return None
 
 
-def peek_filelike_length(stream: typing.Any) -> typing.Optional[int]:
+def peek_filelike_length(stream: typing.Any) -> int | None:
     """
     Given a file-like stream object, return its length in number of bytes
     without reading it into memory.
@@ -374,14 +295,10 @@ async def _get_time(self) -> float:
             import trio
 
             return trio.current_time()
-        elif library == "curio":  # pragma: nocover
-            import curio
-
-            return await curio.clock()
-
-        import asyncio
+        else:
+            import asyncio
 
-        return asyncio.get_event_loop().time()
+            return asyncio.get_event_loop().time()
 
     def sync_start(self) -> None:
         self.started = time.perf_counter()
@@ -403,12 +320,12 @@ class URLPattern:
     A utility class currently used for making lookups against proxy keys...
 
     # Wildcard matching...
-    >>> pattern = URLPattern("all")
+    >>> pattern = URLPattern("all://")
     >>> pattern.matches(httpx.URL("http://example.com"))
     True
 
     # Witch scheme matching...
-    >>> pattern = URLPattern("https")
+    >>> pattern = URLPattern("https://")
     >>> pattern.matches(httpx.URL("https://example.com"))
     True
     >>> pattern.matches(httpx.URL("http://example.com"))
@@ -441,7 +358,7 @@ class URLPattern:
     """
 
     def __init__(self, pattern: str) -> None:
-        from ._models import URL
+        from ._urls import URL
 
         if pattern and ":" not in pattern:
             raise ValueError(
@@ -456,22 +373,21 @@ def __init__(self, pattern: str) -> None:
         self.host = "" if url.host == "*" else url.host
         self.port = url.port
         if not url.host or url.host == "*":
-            self.host_regex: typing.Optional[typing.Pattern[str]] = None
+            self.host_regex: typing.Pattern[str] | None = None
+        elif url.host.startswith("*."):
+            # *.example.com should match "www.example.com", but not "example.com"
+            domain = re.escape(url.host[2:])
+            self.host_regex = re.compile(f"^.+\\.{domain}$")
+        elif url.host.startswith("*"):
+            # *example.com should match "www.example.com" and "example.com"
+            domain = re.escape(url.host[1:])
+            self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
         else:
-            if url.host.startswith("*."):
-                # *.example.com should match "www.example.com", but not "example.com"
-                domain = re.escape(url.host[2:])
-                self.host_regex = re.compile(f"^.+\\.{domain}$")
-            elif url.host.startswith("*"):
-                # *example.com should match "www.example.com" and "example.com"
-                domain = re.escape(url.host[1:])
-                self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
-            else:
-                # example.com should match "example.com" but not "www.example.com"
-                domain = re.escape(url.host)
-                self.host_regex = re.compile(f"^{domain}$")
+            # example.com should match "example.com" but not "www.example.com"
+            domain = re.escape(url.host)
+            self.host_regex = re.compile(f"^{domain}$")
 
-    def matches(self, other: "URL") -> bool:
+    def matches(self, other: URL) -> bool:
         if self.scheme and self.scheme != other.scheme:
             return False
         if (
@@ -485,7 +401,7 @@ def matches(self, other: "URL") -> bool:
         return True
 
     @property
-    def priority(self) -> tuple:
+    def priority(self) -> tuple[int, int, int]:
         """
         The priority allows URLPattern instances to be sortable, so that
         we can match from most specific to least specific.
@@ -501,8 +417,24 @@ def priority(self) -> tuple:
     def __hash__(self) -> int:
         return hash(self.pattern)
 
-    def __lt__(self, other: "URLPattern") -> bool:
+    def __lt__(self, other: URLPattern) -> bool:
         return self.priority < other.priority
 
     def __eq__(self, other: typing.Any) -> bool:
         return isinstance(other, URLPattern) and self.pattern == other.pattern
+
+
+def is_ipv4_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv4Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
+
+
+def is_ipv6_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv6Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
diff --git a/addon/globalPlugins/spellcheck/libs/idna/__init__.py b/addon/globalPlugins/spellcheck/libs/idna/__init__.py
deleted file mode 100644
index a40eeaf..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/__init__.py
+++ /dev/null
@@ -1,44 +0,0 @@
-from .package_data import __version__
-from .core import (
-    IDNABidiError,
-    IDNAError,
-    InvalidCodepoint,
-    InvalidCodepointContext,
-    alabel,
-    check_bidi,
-    check_hyphen_ok,
-    check_initial_combiner,
-    check_label,
-    check_nfc,
-    decode,
-    encode,
-    ulabel,
-    uts46_remap,
-    valid_contextj,
-    valid_contexto,
-    valid_label_length,
-    valid_string_length,
-)
-from .intranges import intranges_contain
-
-__all__ = [
-    "IDNABidiError",
-    "IDNAError",
-    "InvalidCodepoint",
-    "InvalidCodepointContext",
-    "alabel",
-    "check_bidi",
-    "check_hyphen_ok",
-    "check_initial_combiner",
-    "check_label",
-    "check_nfc",
-    "decode",
-    "encode",
-    "intranges_contain",
-    "ulabel",
-    "uts46_remap",
-    "valid_contextj",
-    "valid_contexto",
-    "valid_label_length",
-    "valid_string_length",
-]
diff --git a/addon/globalPlugins/spellcheck/libs/idna/codec.py b/addon/globalPlugins/spellcheck/libs/idna/codec.py
deleted file mode 100644
index bac5dc0..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/codec.py
+++ /dev/null
@@ -1,119 +0,0 @@
-from .core import encode, decode, alabel, ulabel, IDNAError
-import codecs
-import re
-from typing import Tuple, Optional
-
-_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
-
-
-class Codec(codecs.Codec):
-    def encode(self, data, errors="strict"):
-        # type: (str, str) -> Tuple[bytes, int]
-        if errors != "strict":
-            raise IDNAError('Unsupported error handling "{}"'.format(errors))
-
-        if not data:
-            return b"", 0
-
-        return encode(data), len(data)
-
-    def decode(self, data, errors="strict"):
-        # type: (bytes, str) -> Tuple[str, int]
-        if errors != "strict":
-            raise IDNAError('Unsupported error handling "{}"'.format(errors))
-
-        if not data:
-            return "", 0
-
-        return decode(data), len(data)
-
-
-class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
-    def _buffer_encode(self, data, errors, final):  # type: ignore
-        # type: (str, str, bool) -> Tuple[str, int]
-        if errors != "strict":
-            raise IDNAError('Unsupported error handling "{}"'.format(errors))
-
-        if not data:
-            return "", 0
-
-        labels = _unicode_dots_re.split(data)
-        trailing_dot = ""
-        if labels:
-            if not labels[-1]:
-                trailing_dot = "."
-                del labels[-1]
-            elif not final:
-                # Keep potentially unfinished label until the next call
-                del labels[-1]
-                if labels:
-                    trailing_dot = "."
-
-        result = []
-        size = 0
-        for label in labels:
-            result.append(alabel(label))
-            if size:
-                size += 1
-            size += len(label)
-
-        # Join with U+002E
-        result_str = ".".join(result) + trailing_dot  # type: ignore
-        size += len(trailing_dot)
-        return result_str, size
-
-
-class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    def _buffer_decode(self, data, errors, final):  # type: ignore
-        # type: (str, str, bool) -> Tuple[str, int]
-        if errors != "strict":
-            raise IDNAError('Unsupported error handling "{}"'.format(errors))
-
-        if not data:
-            return ("", 0)
-
-        labels = _unicode_dots_re.split(data)
-        trailing_dot = ""
-        if labels:
-            if not labels[-1]:
-                trailing_dot = "."
-                del labels[-1]
-            elif not final:
-                # Keep potentially unfinished label until the next call
-                del labels[-1]
-                if labels:
-                    trailing_dot = "."
-
-        result = []
-        size = 0
-        for label in labels:
-            result.append(ulabel(label))
-            if size:
-                size += 1
-            size += len(label)
-
-        result_str = ".".join(result) + trailing_dot
-        size += len(trailing_dot)
-        return (result_str, size)
-
-
-class StreamWriter(Codec, codecs.StreamWriter):
-    pass
-
-
-class StreamReader(Codec, codecs.StreamReader):
-    pass
-
-
-def getregentry():
-    # type: () -> codecs.CodecInfo
-    # Compatibility as a search_function for codecs.register()
-    return codecs.CodecInfo(
-        name="idna",
-        encode=Codec().encode,  # type: ignore
-        decode=Codec().decode,  # type: ignore
-        incrementalencoder=IncrementalEncoder,
-        incrementaldecoder=IncrementalDecoder,
-        streamwriter=StreamWriter,
-        streamreader=StreamReader,
-    )
diff --git a/addon/globalPlugins/spellcheck/libs/idna/compat.py b/addon/globalPlugins/spellcheck/libs/idna/compat.py
deleted file mode 100644
index a429c29..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/compat.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from .core import *
-from .codec import *
-from typing import Any, Union
-
-
-def ToASCII(label):
-    # type: (str) -> bytes
-    return encode(label)
-
-
-def ToUnicode(label):
-    # type: (Union[bytes, bytearray]) -> str
-    return decode(label)
-
-
-def nameprep(s):
-    # type: (Any) -> None
-    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")
diff --git a/addon/globalPlugins/spellcheck/libs/idna/core.py b/addon/globalPlugins/spellcheck/libs/idna/core.py
deleted file mode 100644
index ac775de..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/core.py
+++ /dev/null
@@ -1,474 +0,0 @@
-from . import idnadata
-import bisect
-import unicodedata
-import re
-from typing import Union, Optional
-from .intranges import intranges_contain
-
-_virama_combining_class = 9
-_alabel_prefix = b"xn--"
-_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
-
-
-class IDNAError(UnicodeError):
-    """Base exception for all IDNA-encoding related problems"""
-
-    pass
-
-
-class IDNABidiError(IDNAError):
-    """Exception when bidirectional requirements are not satisfied"""
-
-    pass
-
-
-class InvalidCodepoint(IDNAError):
-    """Exception when a disallowed or unallocated codepoint is used"""
-
-    pass
-
-
-class InvalidCodepointContext(IDNAError):
-    """Exception when the codepoint is not valid in the context it is used"""
-
-    pass
-
-
-def _combining_class(cp):
-    # type: (int) -> int
-    v = unicodedata.combining(chr(cp))
-    if v == 0:
-        if not unicodedata.name(chr(cp)):
-            raise ValueError("Unknown character in unicodedata")
-    return v
-
-
-def _is_script(cp, script):
-    # type: (str, str) -> bool
-    return intranges_contain(ord(cp), idnadata.scripts[script])
-
-
-def _punycode(s):
-    # type: (str) -> bytes
-    return s.encode("punycode")
-
-
-def _unot(s):
-    # type: (int) -> str
-    return "U+{:04X}".format(s)
-
-
-def valid_label_length(label):
-    # type: (Union[bytes, str]) -> bool
-    if len(label) > 63:
-        return False
-    return True
-
-
-def valid_string_length(label, trailing_dot):
-    # type: (Union[bytes, str], bool) -> bool
-    if len(label) > (254 if trailing_dot else 253):
-        return False
-    return True
-
-
-def check_bidi(label, check_ltr=False):
-    # type: (str, bool) -> bool
-    # Bidi rules should only be applied if string contains RTL characters
-    bidi_label = False
-    for (idx, cp) in enumerate(label, 1):
-        direction = unicodedata.bidirectional(cp)
-        if direction == "":
-            # String likely comes from a newer version of Unicode
-            raise IDNABidiError(
-                "Unknown directionality in label {} at position {}".format(
-                    repr(label), idx
-                )
-            )
-        if direction in ["R", "AL", "AN"]:
-            bidi_label = True
-    if not bidi_label and not check_ltr:
-        return True
-
-    # Bidi rule 1
-    direction = unicodedata.bidirectional(label[0])
-    if direction in ["R", "AL"]:
-        rtl = True
-    elif direction == "L":
-        rtl = False
-    else:
-        raise IDNABidiError(
-            "First codepoint in label {} must be directionality L, R or AL".format(
-                repr(label)
-            )
-        )
-
-    valid_ending = False
-    number_type = None  # type: Optional[str]
-    for (idx, cp) in enumerate(label, 1):
-        direction = unicodedata.bidirectional(cp)
-
-        if rtl:
-            # Bidi rule 2
-            if not direction in [
-                "R",
-                "AL",
-                "AN",
-                "EN",
-                "ES",
-                "CS",
-                "ET",
-                "ON",
-                "BN",
-                "NSM",
-            ]:
-                raise IDNABidiError(
-                    "Invalid direction for codepoint at position {} in a right-to-left label".format(
-                        idx
-                    )
-                )
-            # Bidi rule 3
-            if direction in ["R", "AL", "EN", "AN"]:
-                valid_ending = True
-            elif direction != "NSM":
-                valid_ending = False
-            # Bidi rule 4
-            if direction in ["AN", "EN"]:
-                if not number_type:
-                    number_type = direction
-                else:
-                    if number_type != direction:
-                        raise IDNABidiError(
-                            "Can not mix numeral types in a right-to-left label"
-                        )
-        else:
-            # Bidi rule 5
-            if not direction in ["L", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"]:
-                raise IDNABidiError(
-                    "Invalid direction for codepoint at position {} in a left-to-right label".format(
-                        idx
-                    )
-                )
-            # Bidi rule 6
-            if direction in ["L", "EN"]:
-                valid_ending = True
-            elif direction != "NSM":
-                valid_ending = False
-
-    if not valid_ending:
-        raise IDNABidiError("Label ends with illegal codepoint directionality")
-
-    return True
-
-
-def check_initial_combiner(label):
-    # type: (str) -> bool
-    if unicodedata.category(label[0])[0] == "M":
-        raise IDNAError("Label begins with an illegal combining character")
-    return True
-
-
-def check_hyphen_ok(label):
-    # type: (str) -> bool
-    if label[2:4] == "--":
-        raise IDNAError("Label has disallowed hyphens in 3rd and 4th position")
-    if label[0] == "-" or label[-1] == "-":
-        raise IDNAError("Label must not start or end with a hyphen")
-    return True
-
-
-def check_nfc(label):
-    # type: (str) -> None
-    if unicodedata.normalize("NFC", label) != label:
-        raise IDNAError("Label must be in Normalization Form C")
-
-
-def valid_contextj(label, pos):
-    # type: (str, int) -> bool
-    cp_value = ord(label[pos])
-
-    if cp_value == 0x200C:
-
-        if pos > 0:
-            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
-                return True
-
-        ok = False
-        for i in range(pos - 1, -1, -1):
-            joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == ord("T"):
-                continue
-            if joining_type in [ord("L"), ord("D")]:
-                ok = True
-                break
-
-        if not ok:
-            return False
-
-        ok = False
-        for i in range(pos + 1, len(label)):
-            joining_type = idnadata.joining_types.get(ord(label[i]))
-            if joining_type == ord("T"):
-                continue
-            if joining_type in [ord("R"), ord("D")]:
-                ok = True
-                break
-        return ok
-
-    if cp_value == 0x200D:
-
-        if pos > 0:
-            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
-                return True
-        return False
-
-    else:
-
-        return False
-
-
-def valid_contexto(label, pos, exception=False):
-    # type: (str, int, bool) -> bool
-    cp_value = ord(label[pos])
-
-    if cp_value == 0x00B7:
-        if 0 < pos < len(label) - 1:
-            if ord(label[pos - 1]) == 0x006C and ord(label[pos + 1]) == 0x006C:
-                return True
-        return False
-
-    elif cp_value == 0x0375:
-        if pos < len(label) - 1 and len(label) > 1:
-            return _is_script(label[pos + 1], "Greek")
-        return False
-
-    elif cp_value == 0x05F3 or cp_value == 0x05F4:
-        if pos > 0:
-            return _is_script(label[pos - 1], "Hebrew")
-        return False
-
-    elif cp_value == 0x30FB:
-        for cp in label:
-            if cp == "\u30fb":
-                continue
-            if (
-                _is_script(cp, "Hiragana")
-                or _is_script(cp, "Katakana")
-                or _is_script(cp, "Han")
-            ):
-                return True
-        return False
-
-    elif 0x660 <= cp_value <= 0x669:
-        for cp in label:
-            if 0x6F0 <= ord(cp) <= 0x06F9:
-                return False
-        return True
-
-    elif 0x6F0 <= cp_value <= 0x6F9:
-        for cp in label:
-            if 0x660 <= ord(cp) <= 0x0669:
-                return False
-        return True
-
-    return False
-
-
-def check_label(label):
-    # type: (Union[str, bytes, bytearray]) -> None
-    if isinstance(label, (bytes, bytearray)):
-        label = label.decode("utf-8")
-    if len(label) == 0:
-        raise IDNAError("Empty Label")
-
-    check_nfc(label)
-    check_hyphen_ok(label)
-    check_initial_combiner(label)
-
-    for (pos, cp) in enumerate(label):
-        cp_value = ord(cp)
-        if intranges_contain(cp_value, idnadata.codepoint_classes["PVALID"]):
-            continue
-        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTJ"]):
-            try:
-                if not valid_contextj(label, pos):
-                    raise InvalidCodepointContext(
-                        "Joiner {} not allowed at position {} in {}".format(
-                            _unot(cp_value), pos + 1, repr(label)
-                        )
-                    )
-            except ValueError:
-                raise IDNAError(
-                    "Unknown codepoint adjacent to joiner {} at position {} in {}".format(
-                        _unot(cp_value), pos + 1, repr(label)
-                    )
-                )
-        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTO"]):
-            if not valid_contexto(label, pos):
-                raise InvalidCodepointContext(
-                    "Codepoint {} not allowed at position {} in {}".format(
-                        _unot(cp_value), pos + 1, repr(label)
-                    )
-                )
-        else:
-            raise InvalidCodepoint(
-                "Codepoint {} at position {} of {} not allowed".format(
-                    _unot(cp_value), pos + 1, repr(label)
-                )
-            )
-
-    check_bidi(label)
-
-
-def alabel(label):
-    # type: (str) -> bytes
-    try:
-        label_bytes = label.encode("ascii")
-        ulabel(label_bytes)
-        if not valid_label_length(label_bytes):
-            raise IDNAError("Label too long")
-        return label_bytes
-    except UnicodeEncodeError:
-        pass
-
-    if not label:
-        raise IDNAError("No Input")
-
-    label = str(label)
-    check_label(label)
-    label_bytes = _punycode(label)
-    label_bytes = _alabel_prefix + label_bytes
-
-    if not valid_label_length(label_bytes):
-        raise IDNAError("Label too long")
-
-    return label_bytes
-
-
-def ulabel(label):
-    # type: (Union[str, bytes, bytearray]) -> str
-    if not isinstance(label, (bytes, bytearray)):
-        try:
-            label_bytes = label.encode("ascii")
-        except UnicodeEncodeError:
-            check_label(label)
-            return label
-    else:
-        label_bytes = label
-
-    label_bytes = label_bytes.lower()
-    if label_bytes.startswith(_alabel_prefix):
-        label_bytes = label_bytes[len(_alabel_prefix) :]
-        if not label_bytes:
-            raise IDNAError("Malformed A-label, no Punycode eligible content found")
-        if label_bytes.decode("ascii")[-1] == "-":
-            raise IDNAError("A-label must not end with a hyphen")
-    else:
-        check_label(label_bytes)
-        return label_bytes.decode("ascii")
-
-    label = label_bytes.decode("punycode")
-    check_label(label)
-    return label
-
-
-def uts46_remap(domain, std3_rules=True, transitional=False):
-    # type: (str, bool, bool) -> str
-    """Re-map the characters in the string according to UTS46 processing."""
-    from .uts46data import uts46data
-
-    output = ""
-
-    for pos, char in enumerate(domain):
-        code_point = ord(char)
-        try:
-            uts46row = uts46data[
-                code_point
-                if code_point < 256
-                else bisect.bisect_left(uts46data, (code_point, "Z")) - 1
-            ]
-            status = uts46row[1]
-            replacement = None  # type: Optional[str]
-            if len(uts46row) == 3:
-                replacement = uts46row[2]  # type: ignore
-            if (
-                status == "V"
-                or (status == "D" and not transitional)
-                or (status == "3" and not std3_rules and replacement is None)
-            ):
-                output += char
-            elif replacement is not None and (
-                status == "M"
-                or (status == "3" and not std3_rules)
-                or (status == "D" and transitional)
-            ):
-                output += replacement
-            elif status != "I":
-                raise IndexError()
-        except IndexError:
-            raise InvalidCodepoint(
-                "Codepoint {} not allowed at position {} in {}".format(
-                    _unot(code_point), pos + 1, repr(domain)
-                )
-            )
-
-    return unicodedata.normalize("NFC", output)
-
-
-def encode(s, strict=False, uts46=False, std3_rules=False, transitional=False):
-    # type: (Union[str, bytes, bytearray], bool, bool, bool, bool) -> bytes
-    if isinstance(s, (bytes, bytearray)):
-        s = s.decode("ascii")
-    if uts46:
-        s = uts46_remap(s, std3_rules, transitional)
-    trailing_dot = False
-    result = []
-    if strict:
-        labels = s.split(".")
-    else:
-        labels = _unicode_dots_re.split(s)
-    if not labels or labels == [""]:
-        raise IDNAError("Empty domain")
-    if labels[-1] == "":
-        del labels[-1]
-        trailing_dot = True
-    for label in labels:
-        s = alabel(label)
-        if s:
-            result.append(s)
-        else:
-            raise IDNAError("Empty label")
-    if trailing_dot:
-        result.append(b"")
-    s = b".".join(result)
-    if not valid_string_length(s, trailing_dot):
-        raise IDNAError("Domain too long")
-    return s
-
-
-def decode(s, strict=False, uts46=False, std3_rules=False):
-    # type: (Union[str, bytes, bytearray], bool, bool, bool) -> str
-    if isinstance(s, (bytes, bytearray)):
-        s = s.decode("ascii")
-    if uts46:
-        s = uts46_remap(s, std3_rules, False)
-    trailing_dot = False
-    result = []
-    if not strict:
-        labels = _unicode_dots_re.split(s)
-    else:
-        labels = s.split(".")
-    if not labels or labels == [""]:
-        raise IDNAError("Empty domain")
-    if not labels[-1]:
-        del labels[-1]
-        trailing_dot = True
-    for label in labels:
-        s = ulabel(label)
-        if s:
-            result.append(s)
-        else:
-            raise IDNAError("Empty label")
-    if trailing_dot:
-        result.append("")
-    return ".".join(result)
diff --git a/addon/globalPlugins/spellcheck/libs/idna/idnadata.py b/addon/globalPlugins/spellcheck/libs/idna/idnadata.py
deleted file mode 100644
index d60c561..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/idnadata.py
+++ /dev/null
@@ -1,2048 +0,0 @@
-# This file is automatically generated by tools/idna-data
-
-__version__ = "13.0.0"
-scripts = {
-    "Greek": (
-        0x37000000374,
-        0x37500000378,
-        0x37A0000037E,
-        0x37F00000380,
-        0x38400000385,
-        0x38600000387,
-        0x3880000038B,
-        0x38C0000038D,
-        0x38E000003A2,
-        0x3A3000003E2,
-        0x3F000000400,
-        0x1D2600001D2B,
-        0x1D5D00001D62,
-        0x1D6600001D6B,
-        0x1DBF00001DC0,
-        0x1F0000001F16,
-        0x1F1800001F1E,
-        0x1F2000001F46,
-        0x1F4800001F4E,
-        0x1F5000001F58,
-        0x1F5900001F5A,
-        0x1F5B00001F5C,
-        0x1F5D00001F5E,
-        0x1F5F00001F7E,
-        0x1F8000001FB5,
-        0x1FB600001FC5,
-        0x1FC600001FD4,
-        0x1FD600001FDC,
-        0x1FDD00001FF0,
-        0x1FF200001FF5,
-        0x1FF600001FFF,
-        0x212600002127,
-        0xAB650000AB66,
-        0x101400001018F,
-        0x101A0000101A1,
-        0x1D2000001D246,
-    ),
-    "Han": (
-        0x2E8000002E9A,
-        0x2E9B00002EF4,
-        0x2F0000002FD6,
-        0x300500003006,
-        0x300700003008,
-        0x30210000302A,
-        0x30380000303C,
-        0x340000004DC0,
-        0x4E0000009FFD,
-        0xF9000000FA6E,
-        0xFA700000FADA,
-        0x16FF000016FF2,
-        0x200000002A6DE,
-        0x2A7000002B735,
-        0x2B7400002B81E,
-        0x2B8200002CEA2,
-        0x2CEB00002EBE1,
-        0x2F8000002FA1E,
-        0x300000003134B,
-    ),
-    "Hebrew": (
-        0x591000005C8,
-        0x5D0000005EB,
-        0x5EF000005F5,
-        0xFB1D0000FB37,
-        0xFB380000FB3D,
-        0xFB3E0000FB3F,
-        0xFB400000FB42,
-        0xFB430000FB45,
-        0xFB460000FB50,
-    ),
-    "Hiragana": (
-        0x304100003097,
-        0x309D000030A0,
-        0x1B0010001B11F,
-        0x1B1500001B153,
-        0x1F2000001F201,
-    ),
-    "Katakana": (
-        0x30A1000030FB,
-        0x30FD00003100,
-        0x31F000003200,
-        0x32D0000032FF,
-        0x330000003358,
-        0xFF660000FF70,
-        0xFF710000FF9E,
-        0x1B0000001B001,
-        0x1B1640001B168,
-    ),
-}
-joining_types = {
-    0x600: 85,
-    0x601: 85,
-    0x602: 85,
-    0x603: 85,
-    0x604: 85,
-    0x605: 85,
-    0x608: 85,
-    0x60B: 85,
-    0x620: 68,
-    0x621: 85,
-    0x622: 82,
-    0x623: 82,
-    0x624: 82,
-    0x625: 82,
-    0x626: 68,
-    0x627: 82,
-    0x628: 68,
-    0x629: 82,
-    0x62A: 68,
-    0x62B: 68,
-    0x62C: 68,
-    0x62D: 68,
-    0x62E: 68,
-    0x62F: 82,
-    0x630: 82,
-    0x631: 82,
-    0x632: 82,
-    0x633: 68,
-    0x634: 68,
-    0x635: 68,
-    0x636: 68,
-    0x637: 68,
-    0x638: 68,
-    0x639: 68,
-    0x63A: 68,
-    0x63B: 68,
-    0x63C: 68,
-    0x63D: 68,
-    0x63E: 68,
-    0x63F: 68,
-    0x640: 67,
-    0x641: 68,
-    0x642: 68,
-    0x643: 68,
-    0x644: 68,
-    0x645: 68,
-    0x646: 68,
-    0x647: 68,
-    0x648: 82,
-    0x649: 68,
-    0x64A: 68,
-    0x66E: 68,
-    0x66F: 68,
-    0x671: 82,
-    0x672: 82,
-    0x673: 82,
-    0x674: 85,
-    0x675: 82,
-    0x676: 82,
-    0x677: 82,
-    0x678: 68,
-    0x679: 68,
-    0x67A: 68,
-    0x67B: 68,
-    0x67C: 68,
-    0x67D: 68,
-    0x67E: 68,
-    0x67F: 68,
-    0x680: 68,
-    0x681: 68,
-    0x682: 68,
-    0x683: 68,
-    0x684: 68,
-    0x685: 68,
-    0x686: 68,
-    0x687: 68,
-    0x688: 82,
-    0x689: 82,
-    0x68A: 82,
-    0x68B: 82,
-    0x68C: 82,
-    0x68D: 82,
-    0x68E: 82,
-    0x68F: 82,
-    0x690: 82,
-    0x691: 82,
-    0x692: 82,
-    0x693: 82,
-    0x694: 82,
-    0x695: 82,
-    0x696: 82,
-    0x697: 82,
-    0x698: 82,
-    0x699: 82,
-    0x69A: 68,
-    0x69B: 68,
-    0x69C: 68,
-    0x69D: 68,
-    0x69E: 68,
-    0x69F: 68,
-    0x6A0: 68,
-    0x6A1: 68,
-    0x6A2: 68,
-    0x6A3: 68,
-    0x6A4: 68,
-    0x6A5: 68,
-    0x6A6: 68,
-    0x6A7: 68,
-    0x6A8: 68,
-    0x6A9: 68,
-    0x6AA: 68,
-    0x6AB: 68,
-    0x6AC: 68,
-    0x6AD: 68,
-    0x6AE: 68,
-    0x6AF: 68,
-    0x6B0: 68,
-    0x6B1: 68,
-    0x6B2: 68,
-    0x6B3: 68,
-    0x6B4: 68,
-    0x6B5: 68,
-    0x6B6: 68,
-    0x6B7: 68,
-    0x6B8: 68,
-    0x6B9: 68,
-    0x6BA: 68,
-    0x6BB: 68,
-    0x6BC: 68,
-    0x6BD: 68,
-    0x6BE: 68,
-    0x6BF: 68,
-    0x6C0: 82,
-    0x6C1: 68,
-    0x6C2: 68,
-    0x6C3: 82,
-    0x6C4: 82,
-    0x6C5: 82,
-    0x6C6: 82,
-    0x6C7: 82,
-    0x6C8: 82,
-    0x6C9: 82,
-    0x6CA: 82,
-    0x6CB: 82,
-    0x6CC: 68,
-    0x6CD: 82,
-    0x6CE: 68,
-    0x6CF: 82,
-    0x6D0: 68,
-    0x6D1: 68,
-    0x6D2: 82,
-    0x6D3: 82,
-    0x6D5: 82,
-    0x6DD: 85,
-    0x6EE: 82,
-    0x6EF: 82,
-    0x6FA: 68,
-    0x6FB: 68,
-    0x6FC: 68,
-    0x6FF: 68,
-    0x70F: 84,
-    0x710: 82,
-    0x712: 68,
-    0x713: 68,
-    0x714: 68,
-    0x715: 82,
-    0x716: 82,
-    0x717: 82,
-    0x718: 82,
-    0x719: 82,
-    0x71A: 68,
-    0x71B: 68,
-    0x71C: 68,
-    0x71D: 68,
-    0x71E: 82,
-    0x71F: 68,
-    0x720: 68,
-    0x721: 68,
-    0x722: 68,
-    0x723: 68,
-    0x724: 68,
-    0x725: 68,
-    0x726: 68,
-    0x727: 68,
-    0x728: 82,
-    0x729: 68,
-    0x72A: 82,
-    0x72B: 68,
-    0x72C: 82,
-    0x72D: 68,
-    0x72E: 68,
-    0x72F: 82,
-    0x74D: 82,
-    0x74E: 68,
-    0x74F: 68,
-    0x750: 68,
-    0x751: 68,
-    0x752: 68,
-    0x753: 68,
-    0x754: 68,
-    0x755: 68,
-    0x756: 68,
-    0x757: 68,
-    0x758: 68,
-    0x759: 82,
-    0x75A: 82,
-    0x75B: 82,
-    0x75C: 68,
-    0x75D: 68,
-    0x75E: 68,
-    0x75F: 68,
-    0x760: 68,
-    0x761: 68,
-    0x762: 68,
-    0x763: 68,
-    0x764: 68,
-    0x765: 68,
-    0x766: 68,
-    0x767: 68,
-    0x768: 68,
-    0x769: 68,
-    0x76A: 68,
-    0x76B: 82,
-    0x76C: 82,
-    0x76D: 68,
-    0x76E: 68,
-    0x76F: 68,
-    0x770: 68,
-    0x771: 82,
-    0x772: 68,
-    0x773: 82,
-    0x774: 82,
-    0x775: 68,
-    0x776: 68,
-    0x777: 68,
-    0x778: 82,
-    0x779: 82,
-    0x77A: 68,
-    0x77B: 68,
-    0x77C: 68,
-    0x77D: 68,
-    0x77E: 68,
-    0x77F: 68,
-    0x7CA: 68,
-    0x7CB: 68,
-    0x7CC: 68,
-    0x7CD: 68,
-    0x7CE: 68,
-    0x7CF: 68,
-    0x7D0: 68,
-    0x7D1: 68,
-    0x7D2: 68,
-    0x7D3: 68,
-    0x7D4: 68,
-    0x7D5: 68,
-    0x7D6: 68,
-    0x7D7: 68,
-    0x7D8: 68,
-    0x7D9: 68,
-    0x7DA: 68,
-    0x7DB: 68,
-    0x7DC: 68,
-    0x7DD: 68,
-    0x7DE: 68,
-    0x7DF: 68,
-    0x7E0: 68,
-    0x7E1: 68,
-    0x7E2: 68,
-    0x7E3: 68,
-    0x7E4: 68,
-    0x7E5: 68,
-    0x7E6: 68,
-    0x7E7: 68,
-    0x7E8: 68,
-    0x7E9: 68,
-    0x7EA: 68,
-    0x7FA: 67,
-    0x840: 82,
-    0x841: 68,
-    0x842: 68,
-    0x843: 68,
-    0x844: 68,
-    0x845: 68,
-    0x846: 82,
-    0x847: 82,
-    0x848: 68,
-    0x849: 82,
-    0x84A: 68,
-    0x84B: 68,
-    0x84C: 68,
-    0x84D: 68,
-    0x84E: 68,
-    0x84F: 68,
-    0x850: 68,
-    0x851: 68,
-    0x852: 68,
-    0x853: 68,
-    0x854: 82,
-    0x855: 68,
-    0x856: 82,
-    0x857: 82,
-    0x858: 82,
-    0x860: 68,
-    0x861: 85,
-    0x862: 68,
-    0x863: 68,
-    0x864: 68,
-    0x865: 68,
-    0x866: 85,
-    0x867: 82,
-    0x868: 68,
-    0x869: 82,
-    0x86A: 82,
-    0x8A0: 68,
-    0x8A1: 68,
-    0x8A2: 68,
-    0x8A3: 68,
-    0x8A4: 68,
-    0x8A5: 68,
-    0x8A6: 68,
-    0x8A7: 68,
-    0x8A8: 68,
-    0x8A9: 68,
-    0x8AA: 82,
-    0x8AB: 82,
-    0x8AC: 82,
-    0x8AD: 85,
-    0x8AE: 82,
-    0x8AF: 68,
-    0x8B0: 68,
-    0x8B1: 82,
-    0x8B2: 82,
-    0x8B3: 68,
-    0x8B4: 68,
-    0x8B6: 68,
-    0x8B7: 68,
-    0x8B8: 68,
-    0x8B9: 82,
-    0x8BA: 68,
-    0x8BB: 68,
-    0x8BC: 68,
-    0x8BD: 68,
-    0x8BE: 68,
-    0x8BF: 68,
-    0x8C0: 68,
-    0x8C1: 68,
-    0x8C2: 68,
-    0x8C3: 68,
-    0x8C4: 68,
-    0x8C5: 68,
-    0x8C6: 68,
-    0x8C7: 68,
-    0x8E2: 85,
-    0x1806: 85,
-    0x1807: 68,
-    0x180A: 67,
-    0x180E: 85,
-    0x1820: 68,
-    0x1821: 68,
-    0x1822: 68,
-    0x1823: 68,
-    0x1824: 68,
-    0x1825: 68,
-    0x1826: 68,
-    0x1827: 68,
-    0x1828: 68,
-    0x1829: 68,
-    0x182A: 68,
-    0x182B: 68,
-    0x182C: 68,
-    0x182D: 68,
-    0x182E: 68,
-    0x182F: 68,
-    0x1830: 68,
-    0x1831: 68,
-    0x1832: 68,
-    0x1833: 68,
-    0x1834: 68,
-    0x1835: 68,
-    0x1836: 68,
-    0x1837: 68,
-    0x1838: 68,
-    0x1839: 68,
-    0x183A: 68,
-    0x183B: 68,
-    0x183C: 68,
-    0x183D: 68,
-    0x183E: 68,
-    0x183F: 68,
-    0x1840: 68,
-    0x1841: 68,
-    0x1842: 68,
-    0x1843: 68,
-    0x1844: 68,
-    0x1845: 68,
-    0x1846: 68,
-    0x1847: 68,
-    0x1848: 68,
-    0x1849: 68,
-    0x184A: 68,
-    0x184B: 68,
-    0x184C: 68,
-    0x184D: 68,
-    0x184E: 68,
-    0x184F: 68,
-    0x1850: 68,
-    0x1851: 68,
-    0x1852: 68,
-    0x1853: 68,
-    0x1854: 68,
-    0x1855: 68,
-    0x1856: 68,
-    0x1857: 68,
-    0x1858: 68,
-    0x1859: 68,
-    0x185A: 68,
-    0x185B: 68,
-    0x185C: 68,
-    0x185D: 68,
-    0x185E: 68,
-    0x185F: 68,
-    0x1860: 68,
-    0x1861: 68,
-    0x1862: 68,
-    0x1863: 68,
-    0x1864: 68,
-    0x1865: 68,
-    0x1866: 68,
-    0x1867: 68,
-    0x1868: 68,
-    0x1869: 68,
-    0x186A: 68,
-    0x186B: 68,
-    0x186C: 68,
-    0x186D: 68,
-    0x186E: 68,
-    0x186F: 68,
-    0x1870: 68,
-    0x1871: 68,
-    0x1872: 68,
-    0x1873: 68,
-    0x1874: 68,
-    0x1875: 68,
-    0x1876: 68,
-    0x1877: 68,
-    0x1878: 68,
-    0x1880: 85,
-    0x1881: 85,
-    0x1882: 85,
-    0x1883: 85,
-    0x1884: 85,
-    0x1885: 84,
-    0x1886: 84,
-    0x1887: 68,
-    0x1888: 68,
-    0x1889: 68,
-    0x188A: 68,
-    0x188B: 68,
-    0x188C: 68,
-    0x188D: 68,
-    0x188E: 68,
-    0x188F: 68,
-    0x1890: 68,
-    0x1891: 68,
-    0x1892: 68,
-    0x1893: 68,
-    0x1894: 68,
-    0x1895: 68,
-    0x1896: 68,
-    0x1897: 68,
-    0x1898: 68,
-    0x1899: 68,
-    0x189A: 68,
-    0x189B: 68,
-    0x189C: 68,
-    0x189D: 68,
-    0x189E: 68,
-    0x189F: 68,
-    0x18A0: 68,
-    0x18A1: 68,
-    0x18A2: 68,
-    0x18A3: 68,
-    0x18A4: 68,
-    0x18A5: 68,
-    0x18A6: 68,
-    0x18A7: 68,
-    0x18A8: 68,
-    0x18AA: 68,
-    0x200C: 85,
-    0x200D: 67,
-    0x202F: 85,
-    0x2066: 85,
-    0x2067: 85,
-    0x2068: 85,
-    0x2069: 85,
-    0xA840: 68,
-    0xA841: 68,
-    0xA842: 68,
-    0xA843: 68,
-    0xA844: 68,
-    0xA845: 68,
-    0xA846: 68,
-    0xA847: 68,
-    0xA848: 68,
-    0xA849: 68,
-    0xA84A: 68,
-    0xA84B: 68,
-    0xA84C: 68,
-    0xA84D: 68,
-    0xA84E: 68,
-    0xA84F: 68,
-    0xA850: 68,
-    0xA851: 68,
-    0xA852: 68,
-    0xA853: 68,
-    0xA854: 68,
-    0xA855: 68,
-    0xA856: 68,
-    0xA857: 68,
-    0xA858: 68,
-    0xA859: 68,
-    0xA85A: 68,
-    0xA85B: 68,
-    0xA85C: 68,
-    0xA85D: 68,
-    0xA85E: 68,
-    0xA85F: 68,
-    0xA860: 68,
-    0xA861: 68,
-    0xA862: 68,
-    0xA863: 68,
-    0xA864: 68,
-    0xA865: 68,
-    0xA866: 68,
-    0xA867: 68,
-    0xA868: 68,
-    0xA869: 68,
-    0xA86A: 68,
-    0xA86B: 68,
-    0xA86C: 68,
-    0xA86D: 68,
-    0xA86E: 68,
-    0xA86F: 68,
-    0xA870: 68,
-    0xA871: 68,
-    0xA872: 76,
-    0xA873: 85,
-    0x10AC0: 68,
-    0x10AC1: 68,
-    0x10AC2: 68,
-    0x10AC3: 68,
-    0x10AC4: 68,
-    0x10AC5: 82,
-    0x10AC6: 85,
-    0x10AC7: 82,
-    0x10AC8: 85,
-    0x10AC9: 82,
-    0x10ACA: 82,
-    0x10ACB: 85,
-    0x10ACC: 85,
-    0x10ACD: 76,
-    0x10ACE: 82,
-    0x10ACF: 82,
-    0x10AD0: 82,
-    0x10AD1: 82,
-    0x10AD2: 82,
-    0x10AD3: 68,
-    0x10AD4: 68,
-    0x10AD5: 68,
-    0x10AD6: 68,
-    0x10AD7: 76,
-    0x10AD8: 68,
-    0x10AD9: 68,
-    0x10ADA: 68,
-    0x10ADB: 68,
-    0x10ADC: 68,
-    0x10ADD: 82,
-    0x10ADE: 68,
-    0x10ADF: 68,
-    0x10AE0: 68,
-    0x10AE1: 82,
-    0x10AE2: 85,
-    0x10AE3: 85,
-    0x10AE4: 82,
-    0x10AEB: 68,
-    0x10AEC: 68,
-    0x10AED: 68,
-    0x10AEE: 68,
-    0x10AEF: 82,
-    0x10B80: 68,
-    0x10B81: 82,
-    0x10B82: 68,
-    0x10B83: 82,
-    0x10B84: 82,
-    0x10B85: 82,
-    0x10B86: 68,
-    0x10B87: 68,
-    0x10B88: 68,
-    0x10B89: 82,
-    0x10B8A: 68,
-    0x10B8B: 68,
-    0x10B8C: 82,
-    0x10B8D: 68,
-    0x10B8E: 82,
-    0x10B8F: 82,
-    0x10B90: 68,
-    0x10B91: 82,
-    0x10BA9: 82,
-    0x10BAA: 82,
-    0x10BAB: 82,
-    0x10BAC: 82,
-    0x10BAD: 68,
-    0x10BAE: 68,
-    0x10BAF: 85,
-    0x10D00: 76,
-    0x10D01: 68,
-    0x10D02: 68,
-    0x10D03: 68,
-    0x10D04: 68,
-    0x10D05: 68,
-    0x10D06: 68,
-    0x10D07: 68,
-    0x10D08: 68,
-    0x10D09: 68,
-    0x10D0A: 68,
-    0x10D0B: 68,
-    0x10D0C: 68,
-    0x10D0D: 68,
-    0x10D0E: 68,
-    0x10D0F: 68,
-    0x10D10: 68,
-    0x10D11: 68,
-    0x10D12: 68,
-    0x10D13: 68,
-    0x10D14: 68,
-    0x10D15: 68,
-    0x10D16: 68,
-    0x10D17: 68,
-    0x10D18: 68,
-    0x10D19: 68,
-    0x10D1A: 68,
-    0x10D1B: 68,
-    0x10D1C: 68,
-    0x10D1D: 68,
-    0x10D1E: 68,
-    0x10D1F: 68,
-    0x10D20: 68,
-    0x10D21: 68,
-    0x10D22: 82,
-    0x10D23: 68,
-    0x10F30: 68,
-    0x10F31: 68,
-    0x10F32: 68,
-    0x10F33: 82,
-    0x10F34: 68,
-    0x10F35: 68,
-    0x10F36: 68,
-    0x10F37: 68,
-    0x10F38: 68,
-    0x10F39: 68,
-    0x10F3A: 68,
-    0x10F3B: 68,
-    0x10F3C: 68,
-    0x10F3D: 68,
-    0x10F3E: 68,
-    0x10F3F: 68,
-    0x10F40: 68,
-    0x10F41: 68,
-    0x10F42: 68,
-    0x10F43: 68,
-    0x10F44: 68,
-    0x10F45: 85,
-    0x10F51: 68,
-    0x10F52: 68,
-    0x10F53: 68,
-    0x10F54: 82,
-    0x10FB0: 68,
-    0x10FB1: 85,
-    0x10FB2: 68,
-    0x10FB3: 68,
-    0x10FB4: 82,
-    0x10FB5: 82,
-    0x10FB6: 82,
-    0x10FB7: 85,
-    0x10FB8: 68,
-    0x10FB9: 82,
-    0x10FBA: 82,
-    0x10FBB: 68,
-    0x10FBC: 68,
-    0x10FBD: 82,
-    0x10FBE: 68,
-    0x10FBF: 68,
-    0x10FC0: 85,
-    0x10FC1: 68,
-    0x10FC2: 82,
-    0x10FC3: 82,
-    0x10FC4: 68,
-    0x10FC5: 85,
-    0x10FC6: 85,
-    0x10FC7: 85,
-    0x10FC8: 85,
-    0x10FC9: 82,
-    0x10FCA: 68,
-    0x10FCB: 76,
-    0x110BD: 85,
-    0x110CD: 85,
-    0x1E900: 68,
-    0x1E901: 68,
-    0x1E902: 68,
-    0x1E903: 68,
-    0x1E904: 68,
-    0x1E905: 68,
-    0x1E906: 68,
-    0x1E907: 68,
-    0x1E908: 68,
-    0x1E909: 68,
-    0x1E90A: 68,
-    0x1E90B: 68,
-    0x1E90C: 68,
-    0x1E90D: 68,
-    0x1E90E: 68,
-    0x1E90F: 68,
-    0x1E910: 68,
-    0x1E911: 68,
-    0x1E912: 68,
-    0x1E913: 68,
-    0x1E914: 68,
-    0x1E915: 68,
-    0x1E916: 68,
-    0x1E917: 68,
-    0x1E918: 68,
-    0x1E919: 68,
-    0x1E91A: 68,
-    0x1E91B: 68,
-    0x1E91C: 68,
-    0x1E91D: 68,
-    0x1E91E: 68,
-    0x1E91F: 68,
-    0x1E920: 68,
-    0x1E921: 68,
-    0x1E922: 68,
-    0x1E923: 68,
-    0x1E924: 68,
-    0x1E925: 68,
-    0x1E926: 68,
-    0x1E927: 68,
-    0x1E928: 68,
-    0x1E929: 68,
-    0x1E92A: 68,
-    0x1E92B: 68,
-    0x1E92C: 68,
-    0x1E92D: 68,
-    0x1E92E: 68,
-    0x1E92F: 68,
-    0x1E930: 68,
-    0x1E931: 68,
-    0x1E932: 68,
-    0x1E933: 68,
-    0x1E934: 68,
-    0x1E935: 68,
-    0x1E936: 68,
-    0x1E937: 68,
-    0x1E938: 68,
-    0x1E939: 68,
-    0x1E93A: 68,
-    0x1E93B: 68,
-    0x1E93C: 68,
-    0x1E93D: 68,
-    0x1E93E: 68,
-    0x1E93F: 68,
-    0x1E940: 68,
-    0x1E941: 68,
-    0x1E942: 68,
-    0x1E943: 68,
-    0x1E94B: 84,
-}
-codepoint_classes = {
-    "PVALID": (
-        0x2D0000002E,
-        0x300000003A,
-        0x610000007B,
-        0xDF000000F7,
-        0xF800000100,
-        0x10100000102,
-        0x10300000104,
-        0x10500000106,
-        0x10700000108,
-        0x1090000010A,
-        0x10B0000010C,
-        0x10D0000010E,
-        0x10F00000110,
-        0x11100000112,
-        0x11300000114,
-        0x11500000116,
-        0x11700000118,
-        0x1190000011A,
-        0x11B0000011C,
-        0x11D0000011E,
-        0x11F00000120,
-        0x12100000122,
-        0x12300000124,
-        0x12500000126,
-        0x12700000128,
-        0x1290000012A,
-        0x12B0000012C,
-        0x12D0000012E,
-        0x12F00000130,
-        0x13100000132,
-        0x13500000136,
-        0x13700000139,
-        0x13A0000013B,
-        0x13C0000013D,
-        0x13E0000013F,
-        0x14200000143,
-        0x14400000145,
-        0x14600000147,
-        0x14800000149,
-        0x14B0000014C,
-        0x14D0000014E,
-        0x14F00000150,
-        0x15100000152,
-        0x15300000154,
-        0x15500000156,
-        0x15700000158,
-        0x1590000015A,
-        0x15B0000015C,
-        0x15D0000015E,
-        0x15F00000160,
-        0x16100000162,
-        0x16300000164,
-        0x16500000166,
-        0x16700000168,
-        0x1690000016A,
-        0x16B0000016C,
-        0x16D0000016E,
-        0x16F00000170,
-        0x17100000172,
-        0x17300000174,
-        0x17500000176,
-        0x17700000178,
-        0x17A0000017B,
-        0x17C0000017D,
-        0x17E0000017F,
-        0x18000000181,
-        0x18300000184,
-        0x18500000186,
-        0x18800000189,
-        0x18C0000018E,
-        0x19200000193,
-        0x19500000196,
-        0x1990000019C,
-        0x19E0000019F,
-        0x1A1000001A2,
-        0x1A3000001A4,
-        0x1A5000001A6,
-        0x1A8000001A9,
-        0x1AA000001AC,
-        0x1AD000001AE,
-        0x1B0000001B1,
-        0x1B4000001B5,
-        0x1B6000001B7,
-        0x1B9000001BC,
-        0x1BD000001C4,
-        0x1CE000001CF,
-        0x1D0000001D1,
-        0x1D2000001D3,
-        0x1D4000001D5,
-        0x1D6000001D7,
-        0x1D8000001D9,
-        0x1DA000001DB,
-        0x1DC000001DE,
-        0x1DF000001E0,
-        0x1E1000001E2,
-        0x1E3000001E4,
-        0x1E5000001E6,
-        0x1E7000001E8,
-        0x1E9000001EA,
-        0x1EB000001EC,
-        0x1ED000001EE,
-        0x1EF000001F1,
-        0x1F5000001F6,
-        0x1F9000001FA,
-        0x1FB000001FC,
-        0x1FD000001FE,
-        0x1FF00000200,
-        0x20100000202,
-        0x20300000204,
-        0x20500000206,
-        0x20700000208,
-        0x2090000020A,
-        0x20B0000020C,
-        0x20D0000020E,
-        0x20F00000210,
-        0x21100000212,
-        0x21300000214,
-        0x21500000216,
-        0x21700000218,
-        0x2190000021A,
-        0x21B0000021C,
-        0x21D0000021E,
-        0x21F00000220,
-        0x22100000222,
-        0x22300000224,
-        0x22500000226,
-        0x22700000228,
-        0x2290000022A,
-        0x22B0000022C,
-        0x22D0000022E,
-        0x22F00000230,
-        0x23100000232,
-        0x2330000023A,
-        0x23C0000023D,
-        0x23F00000241,
-        0x24200000243,
-        0x24700000248,
-        0x2490000024A,
-        0x24B0000024C,
-        0x24D0000024E,
-        0x24F000002B0,
-        0x2B9000002C2,
-        0x2C6000002D2,
-        0x2EC000002ED,
-        0x2EE000002EF,
-        0x30000000340,
-        0x34200000343,
-        0x3460000034F,
-        0x35000000370,
-        0x37100000372,
-        0x37300000374,
-        0x37700000378,
-        0x37B0000037E,
-        0x39000000391,
-        0x3AC000003CF,
-        0x3D7000003D8,
-        0x3D9000003DA,
-        0x3DB000003DC,
-        0x3DD000003DE,
-        0x3DF000003E0,
-        0x3E1000003E2,
-        0x3E3000003E4,
-        0x3E5000003E6,
-        0x3E7000003E8,
-        0x3E9000003EA,
-        0x3EB000003EC,
-        0x3ED000003EE,
-        0x3EF000003F0,
-        0x3F3000003F4,
-        0x3F8000003F9,
-        0x3FB000003FD,
-        0x43000000460,
-        0x46100000462,
-        0x46300000464,
-        0x46500000466,
-        0x46700000468,
-        0x4690000046A,
-        0x46B0000046C,
-        0x46D0000046E,
-        0x46F00000470,
-        0x47100000472,
-        0x47300000474,
-        0x47500000476,
-        0x47700000478,
-        0x4790000047A,
-        0x47B0000047C,
-        0x47D0000047E,
-        0x47F00000480,
-        0x48100000482,
-        0x48300000488,
-        0x48B0000048C,
-        0x48D0000048E,
-        0x48F00000490,
-        0x49100000492,
-        0x49300000494,
-        0x49500000496,
-        0x49700000498,
-        0x4990000049A,
-        0x49B0000049C,
-        0x49D0000049E,
-        0x49F000004A0,
-        0x4A1000004A2,
-        0x4A3000004A4,
-        0x4A5000004A6,
-        0x4A7000004A8,
-        0x4A9000004AA,
-        0x4AB000004AC,
-        0x4AD000004AE,
-        0x4AF000004B0,
-        0x4B1000004B2,
-        0x4B3000004B4,
-        0x4B5000004B6,
-        0x4B7000004B8,
-        0x4B9000004BA,
-        0x4BB000004BC,
-        0x4BD000004BE,
-        0x4BF000004C0,
-        0x4C2000004C3,
-        0x4C4000004C5,
-        0x4C6000004C7,
-        0x4C8000004C9,
-        0x4CA000004CB,
-        0x4CC000004CD,
-        0x4CE000004D0,
-        0x4D1000004D2,
-        0x4D3000004D4,
-        0x4D5000004D6,
-        0x4D7000004D8,
-        0x4D9000004DA,
-        0x4DB000004DC,
-        0x4DD000004DE,
-        0x4DF000004E0,
-        0x4E1000004E2,
-        0x4E3000004E4,
-        0x4E5000004E6,
-        0x4E7000004E8,
-        0x4E9000004EA,
-        0x4EB000004EC,
-        0x4ED000004EE,
-        0x4EF000004F0,
-        0x4F1000004F2,
-        0x4F3000004F4,
-        0x4F5000004F6,
-        0x4F7000004F8,
-        0x4F9000004FA,
-        0x4FB000004FC,
-        0x4FD000004FE,
-        0x4FF00000500,
-        0x50100000502,
-        0x50300000504,
-        0x50500000506,
-        0x50700000508,
-        0x5090000050A,
-        0x50B0000050C,
-        0x50D0000050E,
-        0x50F00000510,
-        0x51100000512,
-        0x51300000514,
-        0x51500000516,
-        0x51700000518,
-        0x5190000051A,
-        0x51B0000051C,
-        0x51D0000051E,
-        0x51F00000520,
-        0x52100000522,
-        0x52300000524,
-        0x52500000526,
-        0x52700000528,
-        0x5290000052A,
-        0x52B0000052C,
-        0x52D0000052E,
-        0x52F00000530,
-        0x5590000055A,
-        0x56000000587,
-        0x58800000589,
-        0x591000005BE,
-        0x5BF000005C0,
-        0x5C1000005C3,
-        0x5C4000005C6,
-        0x5C7000005C8,
-        0x5D0000005EB,
-        0x5EF000005F3,
-        0x6100000061B,
-        0x62000000640,
-        0x64100000660,
-        0x66E00000675,
-        0x679000006D4,
-        0x6D5000006DD,
-        0x6DF000006E9,
-        0x6EA000006F0,
-        0x6FA00000700,
-        0x7100000074B,
-        0x74D000007B2,
-        0x7C0000007F6,
-        0x7FD000007FE,
-        0x8000000082E,
-        0x8400000085C,
-        0x8600000086B,
-        0x8A0000008B5,
-        0x8B6000008C8,
-        0x8D3000008E2,
-        0x8E300000958,
-        0x96000000964,
-        0x96600000970,
-        0x97100000984,
-        0x9850000098D,
-        0x98F00000991,
-        0x993000009A9,
-        0x9AA000009B1,
-        0x9B2000009B3,
-        0x9B6000009BA,
-        0x9BC000009C5,
-        0x9C7000009C9,
-        0x9CB000009CF,
-        0x9D7000009D8,
-        0x9E0000009E4,
-        0x9E6000009F2,
-        0x9FC000009FD,
-        0x9FE000009FF,
-        0xA0100000A04,
-        0xA0500000A0B,
-        0xA0F00000A11,
-        0xA1300000A29,
-        0xA2A00000A31,
-        0xA3200000A33,
-        0xA3500000A36,
-        0xA3800000A3A,
-        0xA3C00000A3D,
-        0xA3E00000A43,
-        0xA4700000A49,
-        0xA4B00000A4E,
-        0xA5100000A52,
-        0xA5C00000A5D,
-        0xA6600000A76,
-        0xA8100000A84,
-        0xA8500000A8E,
-        0xA8F00000A92,
-        0xA9300000AA9,
-        0xAAA00000AB1,
-        0xAB200000AB4,
-        0xAB500000ABA,
-        0xABC00000AC6,
-        0xAC700000ACA,
-        0xACB00000ACE,
-        0xAD000000AD1,
-        0xAE000000AE4,
-        0xAE600000AF0,
-        0xAF900000B00,
-        0xB0100000B04,
-        0xB0500000B0D,
-        0xB0F00000B11,
-        0xB1300000B29,
-        0xB2A00000B31,
-        0xB3200000B34,
-        0xB3500000B3A,
-        0xB3C00000B45,
-        0xB4700000B49,
-        0xB4B00000B4E,
-        0xB5500000B58,
-        0xB5F00000B64,
-        0xB6600000B70,
-        0xB7100000B72,
-        0xB8200000B84,
-        0xB8500000B8B,
-        0xB8E00000B91,
-        0xB9200000B96,
-        0xB9900000B9B,
-        0xB9C00000B9D,
-        0xB9E00000BA0,
-        0xBA300000BA5,
-        0xBA800000BAB,
-        0xBAE00000BBA,
-        0xBBE00000BC3,
-        0xBC600000BC9,
-        0xBCA00000BCE,
-        0xBD000000BD1,
-        0xBD700000BD8,
-        0xBE600000BF0,
-        0xC0000000C0D,
-        0xC0E00000C11,
-        0xC1200000C29,
-        0xC2A00000C3A,
-        0xC3D00000C45,
-        0xC4600000C49,
-        0xC4A00000C4E,
-        0xC5500000C57,
-        0xC5800000C5B,
-        0xC6000000C64,
-        0xC6600000C70,
-        0xC8000000C84,
-        0xC8500000C8D,
-        0xC8E00000C91,
-        0xC9200000CA9,
-        0xCAA00000CB4,
-        0xCB500000CBA,
-        0xCBC00000CC5,
-        0xCC600000CC9,
-        0xCCA00000CCE,
-        0xCD500000CD7,
-        0xCDE00000CDF,
-        0xCE000000CE4,
-        0xCE600000CF0,
-        0xCF100000CF3,
-        0xD0000000D0D,
-        0xD0E00000D11,
-        0xD1200000D45,
-        0xD4600000D49,
-        0xD4A00000D4F,
-        0xD5400000D58,
-        0xD5F00000D64,
-        0xD6600000D70,
-        0xD7A00000D80,
-        0xD8100000D84,
-        0xD8500000D97,
-        0xD9A00000DB2,
-        0xDB300000DBC,
-        0xDBD00000DBE,
-        0xDC000000DC7,
-        0xDCA00000DCB,
-        0xDCF00000DD5,
-        0xDD600000DD7,
-        0xDD800000DE0,
-        0xDE600000DF0,
-        0xDF200000DF4,
-        0xE0100000E33,
-        0xE3400000E3B,
-        0xE4000000E4F,
-        0xE5000000E5A,
-        0xE8100000E83,
-        0xE8400000E85,
-        0xE8600000E8B,
-        0xE8C00000EA4,
-        0xEA500000EA6,
-        0xEA700000EB3,
-        0xEB400000EBE,
-        0xEC000000EC5,
-        0xEC600000EC7,
-        0xEC800000ECE,
-        0xED000000EDA,
-        0xEDE00000EE0,
-        0xF0000000F01,
-        0xF0B00000F0C,
-        0xF1800000F1A,
-        0xF2000000F2A,
-        0xF3500000F36,
-        0xF3700000F38,
-        0xF3900000F3A,
-        0xF3E00000F43,
-        0xF4400000F48,
-        0xF4900000F4D,
-        0xF4E00000F52,
-        0xF5300000F57,
-        0xF5800000F5C,
-        0xF5D00000F69,
-        0xF6A00000F6D,
-        0xF7100000F73,
-        0xF7400000F75,
-        0xF7A00000F81,
-        0xF8200000F85,
-        0xF8600000F93,
-        0xF9400000F98,
-        0xF9900000F9D,
-        0xF9E00000FA2,
-        0xFA300000FA7,
-        0xFA800000FAC,
-        0xFAD00000FB9,
-        0xFBA00000FBD,
-        0xFC600000FC7,
-        0x10000000104A,
-        0x10500000109E,
-        0x10D0000010FB,
-        0x10FD00001100,
-        0x120000001249,
-        0x124A0000124E,
-        0x125000001257,
-        0x125800001259,
-        0x125A0000125E,
-        0x126000001289,
-        0x128A0000128E,
-        0x1290000012B1,
-        0x12B2000012B6,
-        0x12B8000012BF,
-        0x12C0000012C1,
-        0x12C2000012C6,
-        0x12C8000012D7,
-        0x12D800001311,
-        0x131200001316,
-        0x13180000135B,
-        0x135D00001360,
-        0x138000001390,
-        0x13A0000013F6,
-        0x14010000166D,
-        0x166F00001680,
-        0x16810000169B,
-        0x16A0000016EB,
-        0x16F1000016F9,
-        0x17000000170D,
-        0x170E00001715,
-        0x172000001735,
-        0x174000001754,
-        0x17600000176D,
-        0x176E00001771,
-        0x177200001774,
-        0x1780000017B4,
-        0x17B6000017D4,
-        0x17D7000017D8,
-        0x17DC000017DE,
-        0x17E0000017EA,
-        0x18100000181A,
-        0x182000001879,
-        0x1880000018AB,
-        0x18B0000018F6,
-        0x19000000191F,
-        0x19200000192C,
-        0x19300000193C,
-        0x19460000196E,
-        0x197000001975,
-        0x1980000019AC,
-        0x19B0000019CA,
-        0x19D0000019DA,
-        0x1A0000001A1C,
-        0x1A2000001A5F,
-        0x1A6000001A7D,
-        0x1A7F00001A8A,
-        0x1A9000001A9A,
-        0x1AA700001AA8,
-        0x1AB000001ABE,
-        0x1ABF00001AC1,
-        0x1B0000001B4C,
-        0x1B5000001B5A,
-        0x1B6B00001B74,
-        0x1B8000001BF4,
-        0x1C0000001C38,
-        0x1C4000001C4A,
-        0x1C4D00001C7E,
-        0x1CD000001CD3,
-        0x1CD400001CFB,
-        0x1D0000001D2C,
-        0x1D2F00001D30,
-        0x1D3B00001D3C,
-        0x1D4E00001D4F,
-        0x1D6B00001D78,
-        0x1D7900001D9B,
-        0x1DC000001DFA,
-        0x1DFB00001E00,
-        0x1E0100001E02,
-        0x1E0300001E04,
-        0x1E0500001E06,
-        0x1E0700001E08,
-        0x1E0900001E0A,
-        0x1E0B00001E0C,
-        0x1E0D00001E0E,
-        0x1E0F00001E10,
-        0x1E1100001E12,
-        0x1E1300001E14,
-        0x1E1500001E16,
-        0x1E1700001E18,
-        0x1E1900001E1A,
-        0x1E1B00001E1C,
-        0x1E1D00001E1E,
-        0x1E1F00001E20,
-        0x1E2100001E22,
-        0x1E2300001E24,
-        0x1E2500001E26,
-        0x1E2700001E28,
-        0x1E2900001E2A,
-        0x1E2B00001E2C,
-        0x1E2D00001E2E,
-        0x1E2F00001E30,
-        0x1E3100001E32,
-        0x1E3300001E34,
-        0x1E3500001E36,
-        0x1E3700001E38,
-        0x1E3900001E3A,
-        0x1E3B00001E3C,
-        0x1E3D00001E3E,
-        0x1E3F00001E40,
-        0x1E4100001E42,
-        0x1E4300001E44,
-        0x1E4500001E46,
-        0x1E4700001E48,
-        0x1E4900001E4A,
-        0x1E4B00001E4C,
-        0x1E4D00001E4E,
-        0x1E4F00001E50,
-        0x1E5100001E52,
-        0x1E5300001E54,
-        0x1E5500001E56,
-        0x1E5700001E58,
-        0x1E5900001E5A,
-        0x1E5B00001E5C,
-        0x1E5D00001E5E,
-        0x1E5F00001E60,
-        0x1E6100001E62,
-        0x1E6300001E64,
-        0x1E6500001E66,
-        0x1E6700001E68,
-        0x1E6900001E6A,
-        0x1E6B00001E6C,
-        0x1E6D00001E6E,
-        0x1E6F00001E70,
-        0x1E7100001E72,
-        0x1E7300001E74,
-        0x1E7500001E76,
-        0x1E7700001E78,
-        0x1E7900001E7A,
-        0x1E7B00001E7C,
-        0x1E7D00001E7E,
-        0x1E7F00001E80,
-        0x1E8100001E82,
-        0x1E8300001E84,
-        0x1E8500001E86,
-        0x1E8700001E88,
-        0x1E8900001E8A,
-        0x1E8B00001E8C,
-        0x1E8D00001E8E,
-        0x1E8F00001E90,
-        0x1E9100001E92,
-        0x1E9300001E94,
-        0x1E9500001E9A,
-        0x1E9C00001E9E,
-        0x1E9F00001EA0,
-        0x1EA100001EA2,
-        0x1EA300001EA4,
-        0x1EA500001EA6,
-        0x1EA700001EA8,
-        0x1EA900001EAA,
-        0x1EAB00001EAC,
-        0x1EAD00001EAE,
-        0x1EAF00001EB0,
-        0x1EB100001EB2,
-        0x1EB300001EB4,
-        0x1EB500001EB6,
-        0x1EB700001EB8,
-        0x1EB900001EBA,
-        0x1EBB00001EBC,
-        0x1EBD00001EBE,
-        0x1EBF00001EC0,
-        0x1EC100001EC2,
-        0x1EC300001EC4,
-        0x1EC500001EC6,
-        0x1EC700001EC8,
-        0x1EC900001ECA,
-        0x1ECB00001ECC,
-        0x1ECD00001ECE,
-        0x1ECF00001ED0,
-        0x1ED100001ED2,
-        0x1ED300001ED4,
-        0x1ED500001ED6,
-        0x1ED700001ED8,
-        0x1ED900001EDA,
-        0x1EDB00001EDC,
-        0x1EDD00001EDE,
-        0x1EDF00001EE0,
-        0x1EE100001EE2,
-        0x1EE300001EE4,
-        0x1EE500001EE6,
-        0x1EE700001EE8,
-        0x1EE900001EEA,
-        0x1EEB00001EEC,
-        0x1EED00001EEE,
-        0x1EEF00001EF0,
-        0x1EF100001EF2,
-        0x1EF300001EF4,
-        0x1EF500001EF6,
-        0x1EF700001EF8,
-        0x1EF900001EFA,
-        0x1EFB00001EFC,
-        0x1EFD00001EFE,
-        0x1EFF00001F08,
-        0x1F1000001F16,
-        0x1F2000001F28,
-        0x1F3000001F38,
-        0x1F4000001F46,
-        0x1F5000001F58,
-        0x1F6000001F68,
-        0x1F7000001F71,
-        0x1F7200001F73,
-        0x1F7400001F75,
-        0x1F7600001F77,
-        0x1F7800001F79,
-        0x1F7A00001F7B,
-        0x1F7C00001F7D,
-        0x1FB000001FB2,
-        0x1FB600001FB7,
-        0x1FC600001FC7,
-        0x1FD000001FD3,
-        0x1FD600001FD8,
-        0x1FE000001FE3,
-        0x1FE400001FE8,
-        0x1FF600001FF7,
-        0x214E0000214F,
-        0x218400002185,
-        0x2C3000002C5F,
-        0x2C6100002C62,
-        0x2C6500002C67,
-        0x2C6800002C69,
-        0x2C6A00002C6B,
-        0x2C6C00002C6D,
-        0x2C7100002C72,
-        0x2C7300002C75,
-        0x2C7600002C7C,
-        0x2C8100002C82,
-        0x2C8300002C84,
-        0x2C8500002C86,
-        0x2C8700002C88,
-        0x2C8900002C8A,
-        0x2C8B00002C8C,
-        0x2C8D00002C8E,
-        0x2C8F00002C90,
-        0x2C9100002C92,
-        0x2C9300002C94,
-        0x2C9500002C96,
-        0x2C9700002C98,
-        0x2C9900002C9A,
-        0x2C9B00002C9C,
-        0x2C9D00002C9E,
-        0x2C9F00002CA0,
-        0x2CA100002CA2,
-        0x2CA300002CA4,
-        0x2CA500002CA6,
-        0x2CA700002CA8,
-        0x2CA900002CAA,
-        0x2CAB00002CAC,
-        0x2CAD00002CAE,
-        0x2CAF00002CB0,
-        0x2CB100002CB2,
-        0x2CB300002CB4,
-        0x2CB500002CB6,
-        0x2CB700002CB8,
-        0x2CB900002CBA,
-        0x2CBB00002CBC,
-        0x2CBD00002CBE,
-        0x2CBF00002CC0,
-        0x2CC100002CC2,
-        0x2CC300002CC4,
-        0x2CC500002CC6,
-        0x2CC700002CC8,
-        0x2CC900002CCA,
-        0x2CCB00002CCC,
-        0x2CCD00002CCE,
-        0x2CCF00002CD0,
-        0x2CD100002CD2,
-        0x2CD300002CD4,
-        0x2CD500002CD6,
-        0x2CD700002CD8,
-        0x2CD900002CDA,
-        0x2CDB00002CDC,
-        0x2CDD00002CDE,
-        0x2CDF00002CE0,
-        0x2CE100002CE2,
-        0x2CE300002CE5,
-        0x2CEC00002CED,
-        0x2CEE00002CF2,
-        0x2CF300002CF4,
-        0x2D0000002D26,
-        0x2D2700002D28,
-        0x2D2D00002D2E,
-        0x2D3000002D68,
-        0x2D7F00002D97,
-        0x2DA000002DA7,
-        0x2DA800002DAF,
-        0x2DB000002DB7,
-        0x2DB800002DBF,
-        0x2DC000002DC7,
-        0x2DC800002DCF,
-        0x2DD000002DD7,
-        0x2DD800002DDF,
-        0x2DE000002E00,
-        0x2E2F00002E30,
-        0x300500003008,
-        0x302A0000302E,
-        0x303C0000303D,
-        0x304100003097,
-        0x30990000309B,
-        0x309D0000309F,
-        0x30A1000030FB,
-        0x30FC000030FF,
-        0x310500003130,
-        0x31A0000031C0,
-        0x31F000003200,
-        0x340000004DC0,
-        0x4E0000009FFD,
-        0xA0000000A48D,
-        0xA4D00000A4FE,
-        0xA5000000A60D,
-        0xA6100000A62C,
-        0xA6410000A642,
-        0xA6430000A644,
-        0xA6450000A646,
-        0xA6470000A648,
-        0xA6490000A64A,
-        0xA64B0000A64C,
-        0xA64D0000A64E,
-        0xA64F0000A650,
-        0xA6510000A652,
-        0xA6530000A654,
-        0xA6550000A656,
-        0xA6570000A658,
-        0xA6590000A65A,
-        0xA65B0000A65C,
-        0xA65D0000A65E,
-        0xA65F0000A660,
-        0xA6610000A662,
-        0xA6630000A664,
-        0xA6650000A666,
-        0xA6670000A668,
-        0xA6690000A66A,
-        0xA66B0000A66C,
-        0xA66D0000A670,
-        0xA6740000A67E,
-        0xA67F0000A680,
-        0xA6810000A682,
-        0xA6830000A684,
-        0xA6850000A686,
-        0xA6870000A688,
-        0xA6890000A68A,
-        0xA68B0000A68C,
-        0xA68D0000A68E,
-        0xA68F0000A690,
-        0xA6910000A692,
-        0xA6930000A694,
-        0xA6950000A696,
-        0xA6970000A698,
-        0xA6990000A69A,
-        0xA69B0000A69C,
-        0xA69E0000A6E6,
-        0xA6F00000A6F2,
-        0xA7170000A720,
-        0xA7230000A724,
-        0xA7250000A726,
-        0xA7270000A728,
-        0xA7290000A72A,
-        0xA72B0000A72C,
-        0xA72D0000A72E,
-        0xA72F0000A732,
-        0xA7330000A734,
-        0xA7350000A736,
-        0xA7370000A738,
-        0xA7390000A73A,
-        0xA73B0000A73C,
-        0xA73D0000A73E,
-        0xA73F0000A740,
-        0xA7410000A742,
-        0xA7430000A744,
-        0xA7450000A746,
-        0xA7470000A748,
-        0xA7490000A74A,
-        0xA74B0000A74C,
-        0xA74D0000A74E,
-        0xA74F0000A750,
-        0xA7510000A752,
-        0xA7530000A754,
-        0xA7550000A756,
-        0xA7570000A758,
-        0xA7590000A75A,
-        0xA75B0000A75C,
-        0xA75D0000A75E,
-        0xA75F0000A760,
-        0xA7610000A762,
-        0xA7630000A764,
-        0xA7650000A766,
-        0xA7670000A768,
-        0xA7690000A76A,
-        0xA76B0000A76C,
-        0xA76D0000A76E,
-        0xA76F0000A770,
-        0xA7710000A779,
-        0xA77A0000A77B,
-        0xA77C0000A77D,
-        0xA77F0000A780,
-        0xA7810000A782,
-        0xA7830000A784,
-        0xA7850000A786,
-        0xA7870000A789,
-        0xA78C0000A78D,
-        0xA78E0000A790,
-        0xA7910000A792,
-        0xA7930000A796,
-        0xA7970000A798,
-        0xA7990000A79A,
-        0xA79B0000A79C,
-        0xA79D0000A79E,
-        0xA79F0000A7A0,
-        0xA7A10000A7A2,
-        0xA7A30000A7A4,
-        0xA7A50000A7A6,
-        0xA7A70000A7A8,
-        0xA7A90000A7AA,
-        0xA7AF0000A7B0,
-        0xA7B50000A7B6,
-        0xA7B70000A7B8,
-        0xA7B90000A7BA,
-        0xA7BB0000A7BC,
-        0xA7BD0000A7BE,
-        0xA7BF0000A7C0,
-        0xA7C30000A7C4,
-        0xA7C80000A7C9,
-        0xA7CA0000A7CB,
-        0xA7F60000A7F8,
-        0xA7FA0000A828,
-        0xA82C0000A82D,
-        0xA8400000A874,
-        0xA8800000A8C6,
-        0xA8D00000A8DA,
-        0xA8E00000A8F8,
-        0xA8FB0000A8FC,
-        0xA8FD0000A92E,
-        0xA9300000A954,
-        0xA9800000A9C1,
-        0xA9CF0000A9DA,
-        0xA9E00000A9FF,
-        0xAA000000AA37,
-        0xAA400000AA4E,
-        0xAA500000AA5A,
-        0xAA600000AA77,
-        0xAA7A0000AAC3,
-        0xAADB0000AADE,
-        0xAAE00000AAF0,
-        0xAAF20000AAF7,
-        0xAB010000AB07,
-        0xAB090000AB0F,
-        0xAB110000AB17,
-        0xAB200000AB27,
-        0xAB280000AB2F,
-        0xAB300000AB5B,
-        0xAB600000AB6A,
-        0xABC00000ABEB,
-        0xABEC0000ABEE,
-        0xABF00000ABFA,
-        0xAC000000D7A4,
-        0xFA0E0000FA10,
-        0xFA110000FA12,
-        0xFA130000FA15,
-        0xFA1F0000FA20,
-        0xFA210000FA22,
-        0xFA230000FA25,
-        0xFA270000FA2A,
-        0xFB1E0000FB1F,
-        0xFE200000FE30,
-        0xFE730000FE74,
-        0x100000001000C,
-        0x1000D00010027,
-        0x100280001003B,
-        0x1003C0001003E,
-        0x1003F0001004E,
-        0x100500001005E,
-        0x10080000100FB,
-        0x101FD000101FE,
-        0x102800001029D,
-        0x102A0000102D1,
-        0x102E0000102E1,
-        0x1030000010320,
-        0x1032D00010341,
-        0x103420001034A,
-        0x103500001037B,
-        0x103800001039E,
-        0x103A0000103C4,
-        0x103C8000103D0,
-        0x104280001049E,
-        0x104A0000104AA,
-        0x104D8000104FC,
-        0x1050000010528,
-        0x1053000010564,
-        0x1060000010737,
-        0x1074000010756,
-        0x1076000010768,
-        0x1080000010806,
-        0x1080800010809,
-        0x1080A00010836,
-        0x1083700010839,
-        0x1083C0001083D,
-        0x1083F00010856,
-        0x1086000010877,
-        0x108800001089F,
-        0x108E0000108F3,
-        0x108F4000108F6,
-        0x1090000010916,
-        0x109200001093A,
-        0x10980000109B8,
-        0x109BE000109C0,
-        0x10A0000010A04,
-        0x10A0500010A07,
-        0x10A0C00010A14,
-        0x10A1500010A18,
-        0x10A1900010A36,
-        0x10A3800010A3B,
-        0x10A3F00010A40,
-        0x10A6000010A7D,
-        0x10A8000010A9D,
-        0x10AC000010AC8,
-        0x10AC900010AE7,
-        0x10B0000010B36,
-        0x10B4000010B56,
-        0x10B6000010B73,
-        0x10B8000010B92,
-        0x10C0000010C49,
-        0x10CC000010CF3,
-        0x10D0000010D28,
-        0x10D3000010D3A,
-        0x10E8000010EAA,
-        0x10EAB00010EAD,
-        0x10EB000010EB2,
-        0x10F0000010F1D,
-        0x10F2700010F28,
-        0x10F3000010F51,
-        0x10FB000010FC5,
-        0x10FE000010FF7,
-        0x1100000011047,
-        0x1106600011070,
-        0x1107F000110BB,
-        0x110D0000110E9,
-        0x110F0000110FA,
-        0x1110000011135,
-        0x1113600011140,
-        0x1114400011148,
-        0x1115000011174,
-        0x1117600011177,
-        0x11180000111C5,
-        0x111C9000111CD,
-        0x111CE000111DB,
-        0x111DC000111DD,
-        0x1120000011212,
-        0x1121300011238,
-        0x1123E0001123F,
-        0x1128000011287,
-        0x1128800011289,
-        0x1128A0001128E,
-        0x1128F0001129E,
-        0x1129F000112A9,
-        0x112B0000112EB,
-        0x112F0000112FA,
-        0x1130000011304,
-        0x113050001130D,
-        0x1130F00011311,
-        0x1131300011329,
-        0x1132A00011331,
-        0x1133200011334,
-        0x113350001133A,
-        0x1133B00011345,
-        0x1134700011349,
-        0x1134B0001134E,
-        0x1135000011351,
-        0x1135700011358,
-        0x1135D00011364,
-        0x113660001136D,
-        0x1137000011375,
-        0x114000001144B,
-        0x114500001145A,
-        0x1145E00011462,
-        0x11480000114C6,
-        0x114C7000114C8,
-        0x114D0000114DA,
-        0x11580000115B6,
-        0x115B8000115C1,
-        0x115D8000115DE,
-        0x1160000011641,
-        0x1164400011645,
-        0x116500001165A,
-        0x11680000116B9,
-        0x116C0000116CA,
-        0x117000001171B,
-        0x1171D0001172C,
-        0x117300001173A,
-        0x118000001183B,
-        0x118C0000118EA,
-        0x118FF00011907,
-        0x119090001190A,
-        0x1190C00011914,
-        0x1191500011917,
-        0x1191800011936,
-        0x1193700011939,
-        0x1193B00011944,
-        0x119500001195A,
-        0x119A0000119A8,
-        0x119AA000119D8,
-        0x119DA000119E2,
-        0x119E3000119E5,
-        0x11A0000011A3F,
-        0x11A4700011A48,
-        0x11A5000011A9A,
-        0x11A9D00011A9E,
-        0x11AC000011AF9,
-        0x11C0000011C09,
-        0x11C0A00011C37,
-        0x11C3800011C41,
-        0x11C5000011C5A,
-        0x11C7200011C90,
-        0x11C9200011CA8,
-        0x11CA900011CB7,
-        0x11D0000011D07,
-        0x11D0800011D0A,
-        0x11D0B00011D37,
-        0x11D3A00011D3B,
-        0x11D3C00011D3E,
-        0x11D3F00011D48,
-        0x11D5000011D5A,
-        0x11D6000011D66,
-        0x11D6700011D69,
-        0x11D6A00011D8F,
-        0x11D9000011D92,
-        0x11D9300011D99,
-        0x11DA000011DAA,
-        0x11EE000011EF7,
-        0x11FB000011FB1,
-        0x120000001239A,
-        0x1248000012544,
-        0x130000001342F,
-        0x1440000014647,
-        0x1680000016A39,
-        0x16A4000016A5F,
-        0x16A6000016A6A,
-        0x16AD000016AEE,
-        0x16AF000016AF5,
-        0x16B0000016B37,
-        0x16B4000016B44,
-        0x16B5000016B5A,
-        0x16B6300016B78,
-        0x16B7D00016B90,
-        0x16E6000016E80,
-        0x16F0000016F4B,
-        0x16F4F00016F88,
-        0x16F8F00016FA0,
-        0x16FE000016FE2,
-        0x16FE300016FE5,
-        0x16FF000016FF2,
-        0x17000000187F8,
-        0x1880000018CD6,
-        0x18D0000018D09,
-        0x1B0000001B11F,
-        0x1B1500001B153,
-        0x1B1640001B168,
-        0x1B1700001B2FC,
-        0x1BC000001BC6B,
-        0x1BC700001BC7D,
-        0x1BC800001BC89,
-        0x1BC900001BC9A,
-        0x1BC9D0001BC9F,
-        0x1DA000001DA37,
-        0x1DA3B0001DA6D,
-        0x1DA750001DA76,
-        0x1DA840001DA85,
-        0x1DA9B0001DAA0,
-        0x1DAA10001DAB0,
-        0x1E0000001E007,
-        0x1E0080001E019,
-        0x1E01B0001E022,
-        0x1E0230001E025,
-        0x1E0260001E02B,
-        0x1E1000001E12D,
-        0x1E1300001E13E,
-        0x1E1400001E14A,
-        0x1E14E0001E14F,
-        0x1E2C00001E2FA,
-        0x1E8000001E8C5,
-        0x1E8D00001E8D7,
-        0x1E9220001E94C,
-        0x1E9500001E95A,
-        0x1FBF00001FBFA,
-        0x200000002A6DE,
-        0x2A7000002B735,
-        0x2B7400002B81E,
-        0x2B8200002CEA2,
-        0x2CEB00002EBE1,
-        0x300000003134B,
-    ),
-    "CONTEXTJ": (0x200C0000200E,),
-    "CONTEXTO": (
-        0xB7000000B8,
-        0x37500000376,
-        0x5F3000005F5,
-        0x6600000066A,
-        0x6F0000006FA,
-        0x30FB000030FC,
-    ),
-}
diff --git a/addon/globalPlugins/spellcheck/libs/idna/intranges.py b/addon/globalPlugins/spellcheck/libs/idna/intranges.py
deleted file mode 100644
index af1315e..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/intranges.py
+++ /dev/null
@@ -1,61 +0,0 @@
-"""
-Given a list of integers, made up of (hopefully) a small number of long runs
-of consecutive integers, compute a representation of the form
-((start1, end1), (start2, end2) ...). Then answer the question "was x present
-in the original list?" in time O(log(# runs)).
-"""
-
-import bisect
-from typing import List, Tuple
-
-
-def intranges_from_list(list_):
-    # type: (List[int]) -> Tuple[int, ...]
-    """Represent a list of integers as a sequence of ranges:
-    ((start_0, end_0), (start_1, end_1), ...), such that the original
-    integers are exactly those x such that start_i <= x < end_i for some i.
-
-    Ranges are encoded as single integers (start << 32 | end), not as tuples.
-    """
-
-    sorted_list = sorted(list_)
-    ranges = []
-    last_write = -1
-    for i in range(len(sorted_list)):
-        if i + 1 < len(sorted_list):
-            if sorted_list[i] == sorted_list[i + 1] - 1:
-                continue
-        current_range = sorted_list[last_write + 1 : i + 1]
-        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
-        last_write = i
-
-    return tuple(ranges)
-
-
-def _encode_range(start, end):
-    # type: (int, int) -> int
-    return (start << 32) | end
-
-
-def _decode_range(r):
-    # type: (int) -> Tuple[int, int]
-    return (r >> 32), (r & ((1 << 32) - 1))
-
-
-def intranges_contain(int_, ranges):
-    # type: (int, Tuple[int, ...]) -> bool
-    """Determine if `int_` falls into one of the ranges in `ranges`."""
-    tuple_ = _encode_range(int_, 0)
-    pos = bisect.bisect_left(ranges, tuple_)
-    # we could be immediately ahead of a tuple (start, end)
-    # with start < int_ <= end
-    if pos > 0:
-        left, right = _decode_range(ranges[pos - 1])
-        if left <= int_ < right:
-            return True
-    # or we could be immediately behind a tuple (int_, end)
-    if pos < len(ranges):
-        left, _ = _decode_range(ranges[pos])
-        if left == int_:
-            return True
-    return False
diff --git a/addon/globalPlugins/spellcheck/libs/idna/package_data.py b/addon/globalPlugins/spellcheck/libs/idna/package_data.py
deleted file mode 100644
index 080e846..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/package_data.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = "3.2"
diff --git a/addon/globalPlugins/spellcheck/libs/idna/py.typed b/addon/globalPlugins/spellcheck/libs/idna/py.typed
deleted file mode 100644
index e69de29..0000000
diff --git a/addon/globalPlugins/spellcheck/libs/idna/uts46data.py b/addon/globalPlugins/spellcheck/libs/idna/uts46data.py
deleted file mode 100644
index 0246c34..0000000
--- a/addon/globalPlugins/spellcheck/libs/idna/uts46data.py
+++ /dev/null
@@ -1,8520 +0,0 @@
-# This file is automatically generated by tools/idna-data
-
-from typing import List, Tuple, Union
-
-"""IDNA Mapping Table from UTS46."""
-
-
-__version__ = "13.0.0"
-
-
-def _seg_0():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x0, "3"),
-        (0x1, "3"),
-        (0x2, "3"),
-        (0x3, "3"),
-        (0x4, "3"),
-        (0x5, "3"),
-        (0x6, "3"),
-        (0x7, "3"),
-        (0x8, "3"),
-        (0x9, "3"),
-        (0xA, "3"),
-        (0xB, "3"),
-        (0xC, "3"),
-        (0xD, "3"),
-        (0xE, "3"),
-        (0xF, "3"),
-        (0x10, "3"),
-        (0x11, "3"),
-        (0x12, "3"),
-        (0x13, "3"),
-        (0x14, "3"),
-        (0x15, "3"),
-        (0x16, "3"),
-        (0x17, "3"),
-        (0x18, "3"),
-        (0x19, "3"),
-        (0x1A, "3"),
-        (0x1B, "3"),
-        (0x1C, "3"),
-        (0x1D, "3"),
-        (0x1E, "3"),
-        (0x1F, "3"),
-        (0x20, "3"),
-        (0x21, "3"),
-        (0x22, "3"),
-        (0x23, "3"),
-        (0x24, "3"),
-        (0x25, "3"),
-        (0x26, "3"),
-        (0x27, "3"),
-        (0x28, "3"),
-        (0x29, "3"),
-        (0x2A, "3"),
-        (0x2B, "3"),
-        (0x2C, "3"),
-        (0x2D, "V"),
-        (0x2E, "V"),
-        (0x2F, "3"),
-        (0x30, "V"),
-        (0x31, "V"),
-        (0x32, "V"),
-        (0x33, "V"),
-        (0x34, "V"),
-        (0x35, "V"),
-        (0x36, "V"),
-        (0x37, "V"),
-        (0x38, "V"),
-        (0x39, "V"),
-        (0x3A, "3"),
-        (0x3B, "3"),
-        (0x3C, "3"),
-        (0x3D, "3"),
-        (0x3E, "3"),
-        (0x3F, "3"),
-        (0x40, "3"),
-        (0x41, "M", "a"),
-        (0x42, "M", "b"),
-        (0x43, "M", "c"),
-        (0x44, "M", "d"),
-        (0x45, "M", "e"),
-        (0x46, "M", "f"),
-        (0x47, "M", "g"),
-        (0x48, "M", "h"),
-        (0x49, "M", "i"),
-        (0x4A, "M", "j"),
-        (0x4B, "M", "k"),
-        (0x4C, "M", "l"),
-        (0x4D, "M", "m"),
-        (0x4E, "M", "n"),
-        (0x4F, "M", "o"),
-        (0x50, "M", "p"),
-        (0x51, "M", "q"),
-        (0x52, "M", "r"),
-        (0x53, "M", "s"),
-        (0x54, "M", "t"),
-        (0x55, "M", "u"),
-        (0x56, "M", "v"),
-        (0x57, "M", "w"),
-        (0x58, "M", "x"),
-        (0x59, "M", "y"),
-        (0x5A, "M", "z"),
-        (0x5B, "3"),
-        (0x5C, "3"),
-        (0x5D, "3"),
-        (0x5E, "3"),
-        (0x5F, "3"),
-        (0x60, "3"),
-        (0x61, "V"),
-        (0x62, "V"),
-        (0x63, "V"),
-    ]
-
-
-def _seg_1():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x64, "V"),
-        (0x65, "V"),
-        (0x66, "V"),
-        (0x67, "V"),
-        (0x68, "V"),
-        (0x69, "V"),
-        (0x6A, "V"),
-        (0x6B, "V"),
-        (0x6C, "V"),
-        (0x6D, "V"),
-        (0x6E, "V"),
-        (0x6F, "V"),
-        (0x70, "V"),
-        (0x71, "V"),
-        (0x72, "V"),
-        (0x73, "V"),
-        (0x74, "V"),
-        (0x75, "V"),
-        (0x76, "V"),
-        (0x77, "V"),
-        (0x78, "V"),
-        (0x79, "V"),
-        (0x7A, "V"),
-        (0x7B, "3"),
-        (0x7C, "3"),
-        (0x7D, "3"),
-        (0x7E, "3"),
-        (0x7F, "3"),
-        (0x80, "X"),
-        (0x81, "X"),
-        (0x82, "X"),
-        (0x83, "X"),
-        (0x84, "X"),
-        (0x85, "X"),
-        (0x86, "X"),
-        (0x87, "X"),
-        (0x88, "X"),
-        (0x89, "X"),
-        (0x8A, "X"),
-        (0x8B, "X"),
-        (0x8C, "X"),
-        (0x8D, "X"),
-        (0x8E, "X"),
-        (0x8F, "X"),
-        (0x90, "X"),
-        (0x91, "X"),
-        (0x92, "X"),
-        (0x93, "X"),
-        (0x94, "X"),
-        (0x95, "X"),
-        (0x96, "X"),
-        (0x97, "X"),
-        (0x98, "X"),
-        (0x99, "X"),
-        (0x9A, "X"),
-        (0x9B, "X"),
-        (0x9C, "X"),
-        (0x9D, "X"),
-        (0x9E, "X"),
-        (0x9F, "X"),
-        (0xA0, "3", " "),
-        (0xA1, "V"),
-        (0xA2, "V"),
-        (0xA3, "V"),
-        (0xA4, "V"),
-        (0xA5, "V"),
-        (0xA6, "V"),
-        (0xA7, "V"),
-        (0xA8, "3", " ̈"),
-        (0xA9, "V"),
-        (0xAA, "M", "a"),
-        (0xAB, "V"),
-        (0xAC, "V"),
-        (0xAD, "I"),
-        (0xAE, "V"),
-        (0xAF, "3", " ̄"),
-        (0xB0, "V"),
-        (0xB1, "V"),
-        (0xB2, "M", "2"),
-        (0xB3, "M", "3"),
-        (0xB4, "3", " ́"),
-        (0xB5, "M", "μ"),
-        (0xB6, "V"),
-        (0xB7, "V"),
-        (0xB8, "3", " ̧"),
-        (0xB9, "M", "1"),
-        (0xBA, "M", "o"),
-        (0xBB, "V"),
-        (0xBC, "M", "1⁄4"),
-        (0xBD, "M", "1⁄2"),
-        (0xBE, "M", "3⁄4"),
-        (0xBF, "V"),
-        (0xC0, "M", "à"),
-        (0xC1, "M", "á"),
-        (0xC2, "M", "â"),
-        (0xC3, "M", "ã"),
-        (0xC4, "M", "ä"),
-        (0xC5, "M", "å"),
-        (0xC6, "M", "æ"),
-        (0xC7, "M", "ç"),
-    ]
-
-
-def _seg_2():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xC8, "M", "è"),
-        (0xC9, "M", "é"),
-        (0xCA, "M", "ê"),
-        (0xCB, "M", "ë"),
-        (0xCC, "M", "ì"),
-        (0xCD, "M", "í"),
-        (0xCE, "M", "î"),
-        (0xCF, "M", "ï"),
-        (0xD0, "M", "ð"),
-        (0xD1, "M", "ñ"),
-        (0xD2, "M", "ò"),
-        (0xD3, "M", "ó"),
-        (0xD4, "M", "ô"),
-        (0xD5, "M", "õ"),
-        (0xD6, "M", "ö"),
-        (0xD7, "V"),
-        (0xD8, "M", "ø"),
-        (0xD9, "M", "ù"),
-        (0xDA, "M", "ú"),
-        (0xDB, "M", "û"),
-        (0xDC, "M", "ü"),
-        (0xDD, "M", "ý"),
-        (0xDE, "M", "þ"),
-        (0xDF, "D", "ss"),
-        (0xE0, "V"),
-        (0xE1, "V"),
-        (0xE2, "V"),
-        (0xE3, "V"),
-        (0xE4, "V"),
-        (0xE5, "V"),
-        (0xE6, "V"),
-        (0xE7, "V"),
-        (0xE8, "V"),
-        (0xE9, "V"),
-        (0xEA, "V"),
-        (0xEB, "V"),
-        (0xEC, "V"),
-        (0xED, "V"),
-        (0xEE, "V"),
-        (0xEF, "V"),
-        (0xF0, "V"),
-        (0xF1, "V"),
-        (0xF2, "V"),
-        (0xF3, "V"),
-        (0xF4, "V"),
-        (0xF5, "V"),
-        (0xF6, "V"),
-        (0xF7, "V"),
-        (0xF8, "V"),
-        (0xF9, "V"),
-        (0xFA, "V"),
-        (0xFB, "V"),
-        (0xFC, "V"),
-        (0xFD, "V"),
-        (0xFE, "V"),
-        (0xFF, "V"),
-        (0x100, "M", "ā"),
-        (0x101, "V"),
-        (0x102, "M", "ă"),
-        (0x103, "V"),
-        (0x104, "M", "ą"),
-        (0x105, "V"),
-        (0x106, "M", "ć"),
-        (0x107, "V"),
-        (0x108, "M", "ĉ"),
-        (0x109, "V"),
-        (0x10A, "M", "ċ"),
-        (0x10B, "V"),
-        (0x10C, "M", "č"),
-        (0x10D, "V"),
-        (0x10E, "M", "ď"),
-        (0x10F, "V"),
-        (0x110, "M", "đ"),
-        (0x111, "V"),
-        (0x112, "M", "ē"),
-        (0x113, "V"),
-        (0x114, "M", "ĕ"),
-        (0x115, "V"),
-        (0x116, "M", "ė"),
-        (0x117, "V"),
-        (0x118, "M", "ę"),
-        (0x119, "V"),
-        (0x11A, "M", "ě"),
-        (0x11B, "V"),
-        (0x11C, "M", "ĝ"),
-        (0x11D, "V"),
-        (0x11E, "M", "ğ"),
-        (0x11F, "V"),
-        (0x120, "M", "ġ"),
-        (0x121, "V"),
-        (0x122, "M", "ģ"),
-        (0x123, "V"),
-        (0x124, "M", "ĥ"),
-        (0x125, "V"),
-        (0x126, "M", "ħ"),
-        (0x127, "V"),
-        (0x128, "M", "ĩ"),
-        (0x129, "V"),
-        (0x12A, "M", "ī"),
-        (0x12B, "V"),
-    ]
-
-
-def _seg_3():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x12C, "M", "ĭ"),
-        (0x12D, "V"),
-        (0x12E, "M", "į"),
-        (0x12F, "V"),
-        (0x130, "M", "i̇"),
-        (0x131, "V"),
-        (0x132, "M", "ij"),
-        (0x134, "M", "ĵ"),
-        (0x135, "V"),
-        (0x136, "M", "ķ"),
-        (0x137, "V"),
-        (0x139, "M", "ĺ"),
-        (0x13A, "V"),
-        (0x13B, "M", "ļ"),
-        (0x13C, "V"),
-        (0x13D, "M", "ľ"),
-        (0x13E, "V"),
-        (0x13F, "M", "l·"),
-        (0x141, "M", "ł"),
-        (0x142, "V"),
-        (0x143, "M", "ń"),
-        (0x144, "V"),
-        (0x145, "M", "ņ"),
-        (0x146, "V"),
-        (0x147, "M", "ň"),
-        (0x148, "V"),
-        (0x149, "M", "ʼn"),
-        (0x14A, "M", "ŋ"),
-        (0x14B, "V"),
-        (0x14C, "M", "ō"),
-        (0x14D, "V"),
-        (0x14E, "M", "ŏ"),
-        (0x14F, "V"),
-        (0x150, "M", "ő"),
-        (0x151, "V"),
-        (0x152, "M", "œ"),
-        (0x153, "V"),
-        (0x154, "M", "ŕ"),
-        (0x155, "V"),
-        (0x156, "M", "ŗ"),
-        (0x157, "V"),
-        (0x158, "M", "ř"),
-        (0x159, "V"),
-        (0x15A, "M", "ś"),
-        (0x15B, "V"),
-        (0x15C, "M", "ŝ"),
-        (0x15D, "V"),
-        (0x15E, "M", "ş"),
-        (0x15F, "V"),
-        (0x160, "M", "š"),
-        (0x161, "V"),
-        (0x162, "M", "ţ"),
-        (0x163, "V"),
-        (0x164, "M", "ť"),
-        (0x165, "V"),
-        (0x166, "M", "ŧ"),
-        (0x167, "V"),
-        (0x168, "M", "ũ"),
-        (0x169, "V"),
-        (0x16A, "M", "ū"),
-        (0x16B, "V"),
-        (0x16C, "M", "ŭ"),
-        (0x16D, "V"),
-        (0x16E, "M", "ů"),
-        (0x16F, "V"),
-        (0x170, "M", "ű"),
-        (0x171, "V"),
-        (0x172, "M", "ų"),
-        (0x173, "V"),
-        (0x174, "M", "ŵ"),
-        (0x175, "V"),
-        (0x176, "M", "ŷ"),
-        (0x177, "V"),
-        (0x178, "M", "ÿ"),
-        (0x179, "M", "ź"),
-        (0x17A, "V"),
-        (0x17B, "M", "ż"),
-        (0x17C, "V"),
-        (0x17D, "M", "ž"),
-        (0x17E, "V"),
-        (0x17F, "M", "s"),
-        (0x180, "V"),
-        (0x181, "M", "ɓ"),
-        (0x182, "M", "ƃ"),
-        (0x183, "V"),
-        (0x184, "M", "ƅ"),
-        (0x185, "V"),
-        (0x186, "M", "ɔ"),
-        (0x187, "M", "ƈ"),
-        (0x188, "V"),
-        (0x189, "M", "ɖ"),
-        (0x18A, "M", "ɗ"),
-        (0x18B, "M", "ƌ"),
-        (0x18C, "V"),
-        (0x18E, "M", "ǝ"),
-        (0x18F, "M", "ə"),
-        (0x190, "M", "ɛ"),
-        (0x191, "M", "ƒ"),
-        (0x192, "V"),
-        (0x193, "M", "ɠ"),
-    ]
-
-
-def _seg_4():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x194, "M", "ɣ"),
-        (0x195, "V"),
-        (0x196, "M", "ɩ"),
-        (0x197, "M", "ɨ"),
-        (0x198, "M", "ƙ"),
-        (0x199, "V"),
-        (0x19C, "M", "ɯ"),
-        (0x19D, "M", "ɲ"),
-        (0x19E, "V"),
-        (0x19F, "M", "ɵ"),
-        (0x1A0, "M", "ơ"),
-        (0x1A1, "V"),
-        (0x1A2, "M", "ƣ"),
-        (0x1A3, "V"),
-        (0x1A4, "M", "ƥ"),
-        (0x1A5, "V"),
-        (0x1A6, "M", "ʀ"),
-        (0x1A7, "M", "ƨ"),
-        (0x1A8, "V"),
-        (0x1A9, "M", "ʃ"),
-        (0x1AA, "V"),
-        (0x1AC, "M", "ƭ"),
-        (0x1AD, "V"),
-        (0x1AE, "M", "ʈ"),
-        (0x1AF, "M", "ư"),
-        (0x1B0, "V"),
-        (0x1B1, "M", "ʊ"),
-        (0x1B2, "M", "ʋ"),
-        (0x1B3, "M", "ƴ"),
-        (0x1B4, "V"),
-        (0x1B5, "M", "ƶ"),
-        (0x1B6, "V"),
-        (0x1B7, "M", "ʒ"),
-        (0x1B8, "M", "ƹ"),
-        (0x1B9, "V"),
-        (0x1BC, "M", "ƽ"),
-        (0x1BD, "V"),
-        (0x1C4, "M", "dž"),
-        (0x1C7, "M", "lj"),
-        (0x1CA, "M", "nj"),
-        (0x1CD, "M", "ǎ"),
-        (0x1CE, "V"),
-        (0x1CF, "M", "ǐ"),
-        (0x1D0, "V"),
-        (0x1D1, "M", "ǒ"),
-        (0x1D2, "V"),
-        (0x1D3, "M", "ǔ"),
-        (0x1D4, "V"),
-        (0x1D5, "M", "ǖ"),
-        (0x1D6, "V"),
-        (0x1D7, "M", "ǘ"),
-        (0x1D8, "V"),
-        (0x1D9, "M", "ǚ"),
-        (0x1DA, "V"),
-        (0x1DB, "M", "ǜ"),
-        (0x1DC, "V"),
-        (0x1DE, "M", "ǟ"),
-        (0x1DF, "V"),
-        (0x1E0, "M", "ǡ"),
-        (0x1E1, "V"),
-        (0x1E2, "M", "ǣ"),
-        (0x1E3, "V"),
-        (0x1E4, "M", "ǥ"),
-        (0x1E5, "V"),
-        (0x1E6, "M", "ǧ"),
-        (0x1E7, "V"),
-        (0x1E8, "M", "ǩ"),
-        (0x1E9, "V"),
-        (0x1EA, "M", "ǫ"),
-        (0x1EB, "V"),
-        (0x1EC, "M", "ǭ"),
-        (0x1ED, "V"),
-        (0x1EE, "M", "ǯ"),
-        (0x1EF, "V"),
-        (0x1F1, "M", "dz"),
-        (0x1F4, "M", "ǵ"),
-        (0x1F5, "V"),
-        (0x1F6, "M", "ƕ"),
-        (0x1F7, "M", "ƿ"),
-        (0x1F8, "M", "ǹ"),
-        (0x1F9, "V"),
-        (0x1FA, "M", "ǻ"),
-        (0x1FB, "V"),
-        (0x1FC, "M", "ǽ"),
-        (0x1FD, "V"),
-        (0x1FE, "M", "ǿ"),
-        (0x1FF, "V"),
-        (0x200, "M", "ȁ"),
-        (0x201, "V"),
-        (0x202, "M", "ȃ"),
-        (0x203, "V"),
-        (0x204, "M", "ȅ"),
-        (0x205, "V"),
-        (0x206, "M", "ȇ"),
-        (0x207, "V"),
-        (0x208, "M", "ȉ"),
-        (0x209, "V"),
-        (0x20A, "M", "ȋ"),
-        (0x20B, "V"),
-        (0x20C, "M", "ȍ"),
-    ]
-
-
-def _seg_5():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x20D, "V"),
-        (0x20E, "M", "ȏ"),
-        (0x20F, "V"),
-        (0x210, "M", "ȑ"),
-        (0x211, "V"),
-        (0x212, "M", "ȓ"),
-        (0x213, "V"),
-        (0x214, "M", "ȕ"),
-        (0x215, "V"),
-        (0x216, "M", "ȗ"),
-        (0x217, "V"),
-        (0x218, "M", "ș"),
-        (0x219, "V"),
-        (0x21A, "M", "ț"),
-        (0x21B, "V"),
-        (0x21C, "M", "ȝ"),
-        (0x21D, "V"),
-        (0x21E, "M", "ȟ"),
-        (0x21F, "V"),
-        (0x220, "M", "ƞ"),
-        (0x221, "V"),
-        (0x222, "M", "ȣ"),
-        (0x223, "V"),
-        (0x224, "M", "ȥ"),
-        (0x225, "V"),
-        (0x226, "M", "ȧ"),
-        (0x227, "V"),
-        (0x228, "M", "ȩ"),
-        (0x229, "V"),
-        (0x22A, "M", "ȫ"),
-        (0x22B, "V"),
-        (0x22C, "M", "ȭ"),
-        (0x22D, "V"),
-        (0x22E, "M", "ȯ"),
-        (0x22F, "V"),
-        (0x230, "M", "ȱ"),
-        (0x231, "V"),
-        (0x232, "M", "ȳ"),
-        (0x233, "V"),
-        (0x23A, "M", "ⱥ"),
-        (0x23B, "M", "ȼ"),
-        (0x23C, "V"),
-        (0x23D, "M", "ƚ"),
-        (0x23E, "M", "ⱦ"),
-        (0x23F, "V"),
-        (0x241, "M", "ɂ"),
-        (0x242, "V"),
-        (0x243, "M", "ƀ"),
-        (0x244, "M", "ʉ"),
-        (0x245, "M", "ʌ"),
-        (0x246, "M", "ɇ"),
-        (0x247, "V"),
-        (0x248, "M", "ɉ"),
-        (0x249, "V"),
-        (0x24A, "M", "ɋ"),
-        (0x24B, "V"),
-        (0x24C, "M", "ɍ"),
-        (0x24D, "V"),
-        (0x24E, "M", "ɏ"),
-        (0x24F, "V"),
-        (0x2B0, "M", "h"),
-        (0x2B1, "M", "ɦ"),
-        (0x2B2, "M", "j"),
-        (0x2B3, "M", "r"),
-        (0x2B4, "M", "ɹ"),
-        (0x2B5, "M", "ɻ"),
-        (0x2B6, "M", "ʁ"),
-        (0x2B7, "M", "w"),
-        (0x2B8, "M", "y"),
-        (0x2B9, "V"),
-        (0x2D8, "3", " ̆"),
-        (0x2D9, "3", " ̇"),
-        (0x2DA, "3", " ̊"),
-        (0x2DB, "3", " ̨"),
-        (0x2DC, "3", " ̃"),
-        (0x2DD, "3", " ̋"),
-        (0x2DE, "V"),
-        (0x2E0, "M", "ɣ"),
-        (0x2E1, "M", "l"),
-        (0x2E2, "M", "s"),
-        (0x2E3, "M", "x"),
-        (0x2E4, "M", "ʕ"),
-        (0x2E5, "V"),
-        (0x340, "M", "̀"),
-        (0x341, "M", "́"),
-        (0x342, "V"),
-        (0x343, "M", "̓"),
-        (0x344, "M", "̈́"),
-        (0x345, "M", "ι"),
-        (0x346, "V"),
-        (0x34F, "I"),
-        (0x350, "V"),
-        (0x370, "M", "ͱ"),
-        (0x371, "V"),
-        (0x372, "M", "ͳ"),
-        (0x373, "V"),
-        (0x374, "M", "ʹ"),
-        (0x375, "V"),
-        (0x376, "M", "ͷ"),
-        (0x377, "V"),
-    ]
-
-
-def _seg_6():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x378, "X"),
-        (0x37A, "3", " ι"),
-        (0x37B, "V"),
-        (0x37E, "3", ";"),
-        (0x37F, "M", "ϳ"),
-        (0x380, "X"),
-        (0x384, "3", " ́"),
-        (0x385, "3", " ̈́"),
-        (0x386, "M", "ά"),
-        (0x387, "M", "·"),
-        (0x388, "M", "έ"),
-        (0x389, "M", "ή"),
-        (0x38A, "M", "ί"),
-        (0x38B, "X"),
-        (0x38C, "M", "ό"),
-        (0x38D, "X"),
-        (0x38E, "M", "ύ"),
-        (0x38F, "M", "ώ"),
-        (0x390, "V"),
-        (0x391, "M", "α"),
-        (0x392, "M", "β"),
-        (0x393, "M", "γ"),
-        (0x394, "M", "δ"),
-        (0x395, "M", "ε"),
-        (0x396, "M", "ζ"),
-        (0x397, "M", "η"),
-        (0x398, "M", "θ"),
-        (0x399, "M", "ι"),
-        (0x39A, "M", "κ"),
-        (0x39B, "M", "λ"),
-        (0x39C, "M", "μ"),
-        (0x39D, "M", "ν"),
-        (0x39E, "M", "ξ"),
-        (0x39F, "M", "ο"),
-        (0x3A0, "M", "π"),
-        (0x3A1, "M", "ρ"),
-        (0x3A2, "X"),
-        (0x3A3, "M", "σ"),
-        (0x3A4, "M", "τ"),
-        (0x3A5, "M", "υ"),
-        (0x3A6, "M", "φ"),
-        (0x3A7, "M", "χ"),
-        (0x3A8, "M", "ψ"),
-        (0x3A9, "M", "ω"),
-        (0x3AA, "M", "ϊ"),
-        (0x3AB, "M", "ϋ"),
-        (0x3AC, "V"),
-        (0x3C2, "D", "σ"),
-        (0x3C3, "V"),
-        (0x3CF, "M", "ϗ"),
-        (0x3D0, "M", "β"),
-        (0x3D1, "M", "θ"),
-        (0x3D2, "M", "υ"),
-        (0x3D3, "M", "ύ"),
-        (0x3D4, "M", "ϋ"),
-        (0x3D5, "M", "φ"),
-        (0x3D6, "M", "π"),
-        (0x3D7, "V"),
-        (0x3D8, "M", "ϙ"),
-        (0x3D9, "V"),
-        (0x3DA, "M", "ϛ"),
-        (0x3DB, "V"),
-        (0x3DC, "M", "ϝ"),
-        (0x3DD, "V"),
-        (0x3DE, "M", "ϟ"),
-        (0x3DF, "V"),
-        (0x3E0, "M", "ϡ"),
-        (0x3E1, "V"),
-        (0x3E2, "M", "ϣ"),
-        (0x3E3, "V"),
-        (0x3E4, "M", "ϥ"),
-        (0x3E5, "V"),
-        (0x3E6, "M", "ϧ"),
-        (0x3E7, "V"),
-        (0x3E8, "M", "ϩ"),
-        (0x3E9, "V"),
-        (0x3EA, "M", "ϫ"),
-        (0x3EB, "V"),
-        (0x3EC, "M", "ϭ"),
-        (0x3ED, "V"),
-        (0x3EE, "M", "ϯ"),
-        (0x3EF, "V"),
-        (0x3F0, "M", "κ"),
-        (0x3F1, "M", "ρ"),
-        (0x3F2, "M", "σ"),
-        (0x3F3, "V"),
-        (0x3F4, "M", "θ"),
-        (0x3F5, "M", "ε"),
-        (0x3F6, "V"),
-        (0x3F7, "M", "ϸ"),
-        (0x3F8, "V"),
-        (0x3F9, "M", "σ"),
-        (0x3FA, "M", "ϻ"),
-        (0x3FB, "V"),
-        (0x3FD, "M", "ͻ"),
-        (0x3FE, "M", "ͼ"),
-        (0x3FF, "M", "ͽ"),
-        (0x400, "M", "ѐ"),
-        (0x401, "M", "ё"),
-        (0x402, "M", "ђ"),
-    ]
-
-
-def _seg_7():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x403, "M", "ѓ"),
-        (0x404, "M", "є"),
-        (0x405, "M", "ѕ"),
-        (0x406, "M", "і"),
-        (0x407, "M", "ї"),
-        (0x408, "M", "ј"),
-        (0x409, "M", "љ"),
-        (0x40A, "M", "њ"),
-        (0x40B, "M", "ћ"),
-        (0x40C, "M", "ќ"),
-        (0x40D, "M", "ѝ"),
-        (0x40E, "M", "ў"),
-        (0x40F, "M", "џ"),
-        (0x410, "M", "а"),
-        (0x411, "M", "б"),
-        (0x412, "M", "в"),
-        (0x413, "M", "г"),
-        (0x414, "M", "д"),
-        (0x415, "M", "е"),
-        (0x416, "M", "ж"),
-        (0x417, "M", "з"),
-        (0x418, "M", "и"),
-        (0x419, "M", "й"),
-        (0x41A, "M", "к"),
-        (0x41B, "M", "л"),
-        (0x41C, "M", "м"),
-        (0x41D, "M", "н"),
-        (0x41E, "M", "о"),
-        (0x41F, "M", "п"),
-        (0x420, "M", "р"),
-        (0x421, "M", "с"),
-        (0x422, "M", "т"),
-        (0x423, "M", "у"),
-        (0x424, "M", "ф"),
-        (0x425, "M", "х"),
-        (0x426, "M", "ц"),
-        (0x427, "M", "ч"),
-        (0x428, "M", "ш"),
-        (0x429, "M", "щ"),
-        (0x42A, "M", "ъ"),
-        (0x42B, "M", "ы"),
-        (0x42C, "M", "ь"),
-        (0x42D, "M", "э"),
-        (0x42E, "M", "ю"),
-        (0x42F, "M", "я"),
-        (0x430, "V"),
-        (0x460, "M", "ѡ"),
-        (0x461, "V"),
-        (0x462, "M", "ѣ"),
-        (0x463, "V"),
-        (0x464, "M", "ѥ"),
-        (0x465, "V"),
-        (0x466, "M", "ѧ"),
-        (0x467, "V"),
-        (0x468, "M", "ѩ"),
-        (0x469, "V"),
-        (0x46A, "M", "ѫ"),
-        (0x46B, "V"),
-        (0x46C, "M", "ѭ"),
-        (0x46D, "V"),
-        (0x46E, "M", "ѯ"),
-        (0x46F, "V"),
-        (0x470, "M", "ѱ"),
-        (0x471, "V"),
-        (0x472, "M", "ѳ"),
-        (0x473, "V"),
-        (0x474, "M", "ѵ"),
-        (0x475, "V"),
-        (0x476, "M", "ѷ"),
-        (0x477, "V"),
-        (0x478, "M", "ѹ"),
-        (0x479, "V"),
-        (0x47A, "M", "ѻ"),
-        (0x47B, "V"),
-        (0x47C, "M", "ѽ"),
-        (0x47D, "V"),
-        (0x47E, "M", "ѿ"),
-        (0x47F, "V"),
-        (0x480, "M", "ҁ"),
-        (0x481, "V"),
-        (0x48A, "M", "ҋ"),
-        (0x48B, "V"),
-        (0x48C, "M", "ҍ"),
-        (0x48D, "V"),
-        (0x48E, "M", "ҏ"),
-        (0x48F, "V"),
-        (0x490, "M", "ґ"),
-        (0x491, "V"),
-        (0x492, "M", "ғ"),
-        (0x493, "V"),
-        (0x494, "M", "ҕ"),
-        (0x495, "V"),
-        (0x496, "M", "җ"),
-        (0x497, "V"),
-        (0x498, "M", "ҙ"),
-        (0x499, "V"),
-        (0x49A, "M", "қ"),
-        (0x49B, "V"),
-        (0x49C, "M", "ҝ"),
-        (0x49D, "V"),
-    ]
-
-
-def _seg_8():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x49E, "M", "ҟ"),
-        (0x49F, "V"),
-        (0x4A0, "M", "ҡ"),
-        (0x4A1, "V"),
-        (0x4A2, "M", "ң"),
-        (0x4A3, "V"),
-        (0x4A4, "M", "ҥ"),
-        (0x4A5, "V"),
-        (0x4A6, "M", "ҧ"),
-        (0x4A7, "V"),
-        (0x4A8, "M", "ҩ"),
-        (0x4A9, "V"),
-        (0x4AA, "M", "ҫ"),
-        (0x4AB, "V"),
-        (0x4AC, "M", "ҭ"),
-        (0x4AD, "V"),
-        (0x4AE, "M", "ү"),
-        (0x4AF, "V"),
-        (0x4B0, "M", "ұ"),
-        (0x4B1, "V"),
-        (0x4B2, "M", "ҳ"),
-        (0x4B3, "V"),
-        (0x4B4, "M", "ҵ"),
-        (0x4B5, "V"),
-        (0x4B6, "M", "ҷ"),
-        (0x4B7, "V"),
-        (0x4B8, "M", "ҹ"),
-        (0x4B9, "V"),
-        (0x4BA, "M", "һ"),
-        (0x4BB, "V"),
-        (0x4BC, "M", "ҽ"),
-        (0x4BD, "V"),
-        (0x4BE, "M", "ҿ"),
-        (0x4BF, "V"),
-        (0x4C0, "X"),
-        (0x4C1, "M", "ӂ"),
-        (0x4C2, "V"),
-        (0x4C3, "M", "ӄ"),
-        (0x4C4, "V"),
-        (0x4C5, "M", "ӆ"),
-        (0x4C6, "V"),
-        (0x4C7, "M", "ӈ"),
-        (0x4C8, "V"),
-        (0x4C9, "M", "ӊ"),
-        (0x4CA, "V"),
-        (0x4CB, "M", "ӌ"),
-        (0x4CC, "V"),
-        (0x4CD, "M", "ӎ"),
-        (0x4CE, "V"),
-        (0x4D0, "M", "ӑ"),
-        (0x4D1, "V"),
-        (0x4D2, "M", "ӓ"),
-        (0x4D3, "V"),
-        (0x4D4, "M", "ӕ"),
-        (0x4D5, "V"),
-        (0x4D6, "M", "ӗ"),
-        (0x4D7, "V"),
-        (0x4D8, "M", "ә"),
-        (0x4D9, "V"),
-        (0x4DA, "M", "ӛ"),
-        (0x4DB, "V"),
-        (0x4DC, "M", "ӝ"),
-        (0x4DD, "V"),
-        (0x4DE, "M", "ӟ"),
-        (0x4DF, "V"),
-        (0x4E0, "M", "ӡ"),
-        (0x4E1, "V"),
-        (0x4E2, "M", "ӣ"),
-        (0x4E3, "V"),
-        (0x4E4, "M", "ӥ"),
-        (0x4E5, "V"),
-        (0x4E6, "M", "ӧ"),
-        (0x4E7, "V"),
-        (0x4E8, "M", "ө"),
-        (0x4E9, "V"),
-        (0x4EA, "M", "ӫ"),
-        (0x4EB, "V"),
-        (0x4EC, "M", "ӭ"),
-        (0x4ED, "V"),
-        (0x4EE, "M", "ӯ"),
-        (0x4EF, "V"),
-        (0x4F0, "M", "ӱ"),
-        (0x4F1, "V"),
-        (0x4F2, "M", "ӳ"),
-        (0x4F3, "V"),
-        (0x4F4, "M", "ӵ"),
-        (0x4F5, "V"),
-        (0x4F6, "M", "ӷ"),
-        (0x4F7, "V"),
-        (0x4F8, "M", "ӹ"),
-        (0x4F9, "V"),
-        (0x4FA, "M", "ӻ"),
-        (0x4FB, "V"),
-        (0x4FC, "M", "ӽ"),
-        (0x4FD, "V"),
-        (0x4FE, "M", "ӿ"),
-        (0x4FF, "V"),
-        (0x500, "M", "ԁ"),
-        (0x501, "V"),
-        (0x502, "M", "ԃ"),
-    ]
-
-
-def _seg_9():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x503, "V"),
-        (0x504, "M", "ԅ"),
-        (0x505, "V"),
-        (0x506, "M", "ԇ"),
-        (0x507, "V"),
-        (0x508, "M", "ԉ"),
-        (0x509, "V"),
-        (0x50A, "M", "ԋ"),
-        (0x50B, "V"),
-        (0x50C, "M", "ԍ"),
-        (0x50D, "V"),
-        (0x50E, "M", "ԏ"),
-        (0x50F, "V"),
-        (0x510, "M", "ԑ"),
-        (0x511, "V"),
-        (0x512, "M", "ԓ"),
-        (0x513, "V"),
-        (0x514, "M", "ԕ"),
-        (0x515, "V"),
-        (0x516, "M", "ԗ"),
-        (0x517, "V"),
-        (0x518, "M", "ԙ"),
-        (0x519, "V"),
-        (0x51A, "M", "ԛ"),
-        (0x51B, "V"),
-        (0x51C, "M", "ԝ"),
-        (0x51D, "V"),
-        (0x51E, "M", "ԟ"),
-        (0x51F, "V"),
-        (0x520, "M", "ԡ"),
-        (0x521, "V"),
-        (0x522, "M", "ԣ"),
-        (0x523, "V"),
-        (0x524, "M", "ԥ"),
-        (0x525, "V"),
-        (0x526, "M", "ԧ"),
-        (0x527, "V"),
-        (0x528, "M", "ԩ"),
-        (0x529, "V"),
-        (0x52A, "M", "ԫ"),
-        (0x52B, "V"),
-        (0x52C, "M", "ԭ"),
-        (0x52D, "V"),
-        (0x52E, "M", "ԯ"),
-        (0x52F, "V"),
-        (0x530, "X"),
-        (0x531, "M", "ա"),
-        (0x532, "M", "բ"),
-        (0x533, "M", "գ"),
-        (0x534, "M", "դ"),
-        (0x535, "M", "ե"),
-        (0x536, "M", "զ"),
-        (0x537, "M", "է"),
-        (0x538, "M", "ը"),
-        (0x539, "M", "թ"),
-        (0x53A, "M", "ժ"),
-        (0x53B, "M", "ի"),
-        (0x53C, "M", "լ"),
-        (0x53D, "M", "խ"),
-        (0x53E, "M", "ծ"),
-        (0x53F, "M", "կ"),
-        (0x540, "M", "հ"),
-        (0x541, "M", "ձ"),
-        (0x542, "M", "ղ"),
-        (0x543, "M", "ճ"),
-        (0x544, "M", "մ"),
-        (0x545, "M", "յ"),
-        (0x546, "M", "ն"),
-        (0x547, "M", "շ"),
-        (0x548, "M", "ո"),
-        (0x549, "M", "չ"),
-        (0x54A, "M", "պ"),
-        (0x54B, "M", "ջ"),
-        (0x54C, "M", "ռ"),
-        (0x54D, "M", "ս"),
-        (0x54E, "M", "վ"),
-        (0x54F, "M", "տ"),
-        (0x550, "M", "ր"),
-        (0x551, "M", "ց"),
-        (0x552, "M", "ւ"),
-        (0x553, "M", "փ"),
-        (0x554, "M", "ք"),
-        (0x555, "M", "օ"),
-        (0x556, "M", "ֆ"),
-        (0x557, "X"),
-        (0x559, "V"),
-        (0x587, "M", "եւ"),
-        (0x588, "V"),
-        (0x58B, "X"),
-        (0x58D, "V"),
-        (0x590, "X"),
-        (0x591, "V"),
-        (0x5C8, "X"),
-        (0x5D0, "V"),
-        (0x5EB, "X"),
-        (0x5EF, "V"),
-        (0x5F5, "X"),
-        (0x606, "V"),
-        (0x61C, "X"),
-        (0x61E, "V"),
-    ]
-
-
-def _seg_10():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x675, "M", "اٴ"),
-        (0x676, "M", "وٴ"),
-        (0x677, "M", "ۇٴ"),
-        (0x678, "M", "يٴ"),
-        (0x679, "V"),
-        (0x6DD, "X"),
-        (0x6DE, "V"),
-        (0x70E, "X"),
-        (0x710, "V"),
-        (0x74B, "X"),
-        (0x74D, "V"),
-        (0x7B2, "X"),
-        (0x7C0, "V"),
-        (0x7FB, "X"),
-        (0x7FD, "V"),
-        (0x82E, "X"),
-        (0x830, "V"),
-        (0x83F, "X"),
-        (0x840, "V"),
-        (0x85C, "X"),
-        (0x85E, "V"),
-        (0x85F, "X"),
-        (0x860, "V"),
-        (0x86B, "X"),
-        (0x8A0, "V"),
-        (0x8B5, "X"),
-        (0x8B6, "V"),
-        (0x8C8, "X"),
-        (0x8D3, "V"),
-        (0x8E2, "X"),
-        (0x8E3, "V"),
-        (0x958, "M", "क़"),
-        (0x959, "M", "ख़"),
-        (0x95A, "M", "ग़"),
-        (0x95B, "M", "ज़"),
-        (0x95C, "M", "ड़"),
-        (0x95D, "M", "ढ़"),
-        (0x95E, "M", "फ़"),
-        (0x95F, "M", "य़"),
-        (0x960, "V"),
-        (0x984, "X"),
-        (0x985, "V"),
-        (0x98D, "X"),
-        (0x98F, "V"),
-        (0x991, "X"),
-        (0x993, "V"),
-        (0x9A9, "X"),
-        (0x9AA, "V"),
-        (0x9B1, "X"),
-        (0x9B2, "V"),
-        (0x9B3, "X"),
-        (0x9B6, "V"),
-        (0x9BA, "X"),
-        (0x9BC, "V"),
-        (0x9C5, "X"),
-        (0x9C7, "V"),
-        (0x9C9, "X"),
-        (0x9CB, "V"),
-        (0x9CF, "X"),
-        (0x9D7, "V"),
-        (0x9D8, "X"),
-        (0x9DC, "M", "ড়"),
-        (0x9DD, "M", "ঢ়"),
-        (0x9DE, "X"),
-        (0x9DF, "M", "য়"),
-        (0x9E0, "V"),
-        (0x9E4, "X"),
-        (0x9E6, "V"),
-        (0x9FF, "X"),
-        (0xA01, "V"),
-        (0xA04, "X"),
-        (0xA05, "V"),
-        (0xA0B, "X"),
-        (0xA0F, "V"),
-        (0xA11, "X"),
-        (0xA13, "V"),
-        (0xA29, "X"),
-        (0xA2A, "V"),
-        (0xA31, "X"),
-        (0xA32, "V"),
-        (0xA33, "M", "ਲ਼"),
-        (0xA34, "X"),
-        (0xA35, "V"),
-        (0xA36, "M", "ਸ਼"),
-        (0xA37, "X"),
-        (0xA38, "V"),
-        (0xA3A, "X"),
-        (0xA3C, "V"),
-        (0xA3D, "X"),
-        (0xA3E, "V"),
-        (0xA43, "X"),
-        (0xA47, "V"),
-        (0xA49, "X"),
-        (0xA4B, "V"),
-        (0xA4E, "X"),
-        (0xA51, "V"),
-        (0xA52, "X"),
-        (0xA59, "M", "ਖ਼"),
-        (0xA5A, "M", "ਗ਼"),
-        (0xA5B, "M", "ਜ਼"),
-    ]
-
-
-def _seg_11():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xA5C, "V"),
-        (0xA5D, "X"),
-        (0xA5E, "M", "ਫ਼"),
-        (0xA5F, "X"),
-        (0xA66, "V"),
-        (0xA77, "X"),
-        (0xA81, "V"),
-        (0xA84, "X"),
-        (0xA85, "V"),
-        (0xA8E, "X"),
-        (0xA8F, "V"),
-        (0xA92, "X"),
-        (0xA93, "V"),
-        (0xAA9, "X"),
-        (0xAAA, "V"),
-        (0xAB1, "X"),
-        (0xAB2, "V"),
-        (0xAB4, "X"),
-        (0xAB5, "V"),
-        (0xABA, "X"),
-        (0xABC, "V"),
-        (0xAC6, "X"),
-        (0xAC7, "V"),
-        (0xACA, "X"),
-        (0xACB, "V"),
-        (0xACE, "X"),
-        (0xAD0, "V"),
-        (0xAD1, "X"),
-        (0xAE0, "V"),
-        (0xAE4, "X"),
-        (0xAE6, "V"),
-        (0xAF2, "X"),
-        (0xAF9, "V"),
-        (0xB00, "X"),
-        (0xB01, "V"),
-        (0xB04, "X"),
-        (0xB05, "V"),
-        (0xB0D, "X"),
-        (0xB0F, "V"),
-        (0xB11, "X"),
-        (0xB13, "V"),
-        (0xB29, "X"),
-        (0xB2A, "V"),
-        (0xB31, "X"),
-        (0xB32, "V"),
-        (0xB34, "X"),
-        (0xB35, "V"),
-        (0xB3A, "X"),
-        (0xB3C, "V"),
-        (0xB45, "X"),
-        (0xB47, "V"),
-        (0xB49, "X"),
-        (0xB4B, "V"),
-        (0xB4E, "X"),
-        (0xB55, "V"),
-        (0xB58, "X"),
-        (0xB5C, "M", "ଡ଼"),
-        (0xB5D, "M", "ଢ଼"),
-        (0xB5E, "X"),
-        (0xB5F, "V"),
-        (0xB64, "X"),
-        (0xB66, "V"),
-        (0xB78, "X"),
-        (0xB82, "V"),
-        (0xB84, "X"),
-        (0xB85, "V"),
-        (0xB8B, "X"),
-        (0xB8E, "V"),
-        (0xB91, "X"),
-        (0xB92, "V"),
-        (0xB96, "X"),
-        (0xB99, "V"),
-        (0xB9B, "X"),
-        (0xB9C, "V"),
-        (0xB9D, "X"),
-        (0xB9E, "V"),
-        (0xBA0, "X"),
-        (0xBA3, "V"),
-        (0xBA5, "X"),
-        (0xBA8, "V"),
-        (0xBAB, "X"),
-        (0xBAE, "V"),
-        (0xBBA, "X"),
-        (0xBBE, "V"),
-        (0xBC3, "X"),
-        (0xBC6, "V"),
-        (0xBC9, "X"),
-        (0xBCA, "V"),
-        (0xBCE, "X"),
-        (0xBD0, "V"),
-        (0xBD1, "X"),
-        (0xBD7, "V"),
-        (0xBD8, "X"),
-        (0xBE6, "V"),
-        (0xBFB, "X"),
-        (0xC00, "V"),
-        (0xC0D, "X"),
-        (0xC0E, "V"),
-        (0xC11, "X"),
-        (0xC12, "V"),
-    ]
-
-
-def _seg_12():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xC29, "X"),
-        (0xC2A, "V"),
-        (0xC3A, "X"),
-        (0xC3D, "V"),
-        (0xC45, "X"),
-        (0xC46, "V"),
-        (0xC49, "X"),
-        (0xC4A, "V"),
-        (0xC4E, "X"),
-        (0xC55, "V"),
-        (0xC57, "X"),
-        (0xC58, "V"),
-        (0xC5B, "X"),
-        (0xC60, "V"),
-        (0xC64, "X"),
-        (0xC66, "V"),
-        (0xC70, "X"),
-        (0xC77, "V"),
-        (0xC8D, "X"),
-        (0xC8E, "V"),
-        (0xC91, "X"),
-        (0xC92, "V"),
-        (0xCA9, "X"),
-        (0xCAA, "V"),
-        (0xCB4, "X"),
-        (0xCB5, "V"),
-        (0xCBA, "X"),
-        (0xCBC, "V"),
-        (0xCC5, "X"),
-        (0xCC6, "V"),
-        (0xCC9, "X"),
-        (0xCCA, "V"),
-        (0xCCE, "X"),
-        (0xCD5, "V"),
-        (0xCD7, "X"),
-        (0xCDE, "V"),
-        (0xCDF, "X"),
-        (0xCE0, "V"),
-        (0xCE4, "X"),
-        (0xCE6, "V"),
-        (0xCF0, "X"),
-        (0xCF1, "V"),
-        (0xCF3, "X"),
-        (0xD00, "V"),
-        (0xD0D, "X"),
-        (0xD0E, "V"),
-        (0xD11, "X"),
-        (0xD12, "V"),
-        (0xD45, "X"),
-        (0xD46, "V"),
-        (0xD49, "X"),
-        (0xD4A, "V"),
-        (0xD50, "X"),
-        (0xD54, "V"),
-        (0xD64, "X"),
-        (0xD66, "V"),
-        (0xD80, "X"),
-        (0xD81, "V"),
-        (0xD84, "X"),
-        (0xD85, "V"),
-        (0xD97, "X"),
-        (0xD9A, "V"),
-        (0xDB2, "X"),
-        (0xDB3, "V"),
-        (0xDBC, "X"),
-        (0xDBD, "V"),
-        (0xDBE, "X"),
-        (0xDC0, "V"),
-        (0xDC7, "X"),
-        (0xDCA, "V"),
-        (0xDCB, "X"),
-        (0xDCF, "V"),
-        (0xDD5, "X"),
-        (0xDD6, "V"),
-        (0xDD7, "X"),
-        (0xDD8, "V"),
-        (0xDE0, "X"),
-        (0xDE6, "V"),
-        (0xDF0, "X"),
-        (0xDF2, "V"),
-        (0xDF5, "X"),
-        (0xE01, "V"),
-        (0xE33, "M", "ํา"),
-        (0xE34, "V"),
-        (0xE3B, "X"),
-        (0xE3F, "V"),
-        (0xE5C, "X"),
-        (0xE81, "V"),
-        (0xE83, "X"),
-        (0xE84, "V"),
-        (0xE85, "X"),
-        (0xE86, "V"),
-        (0xE8B, "X"),
-        (0xE8C, "V"),
-        (0xEA4, "X"),
-        (0xEA5, "V"),
-        (0xEA6, "X"),
-        (0xEA7, "V"),
-        (0xEB3, "M", "ໍາ"),
-        (0xEB4, "V"),
-    ]
-
-
-def _seg_13():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xEBE, "X"),
-        (0xEC0, "V"),
-        (0xEC5, "X"),
-        (0xEC6, "V"),
-        (0xEC7, "X"),
-        (0xEC8, "V"),
-        (0xECE, "X"),
-        (0xED0, "V"),
-        (0xEDA, "X"),
-        (0xEDC, "M", "ຫນ"),
-        (0xEDD, "M", "ຫມ"),
-        (0xEDE, "V"),
-        (0xEE0, "X"),
-        (0xF00, "V"),
-        (0xF0C, "M", "་"),
-        (0xF0D, "V"),
-        (0xF43, "M", "གྷ"),
-        (0xF44, "V"),
-        (0xF48, "X"),
-        (0xF49, "V"),
-        (0xF4D, "M", "ཌྷ"),
-        (0xF4E, "V"),
-        (0xF52, "M", "དྷ"),
-        (0xF53, "V"),
-        (0xF57, "M", "བྷ"),
-        (0xF58, "V"),
-        (0xF5C, "M", "ཛྷ"),
-        (0xF5D, "V"),
-        (0xF69, "M", "ཀྵ"),
-        (0xF6A, "V"),
-        (0xF6D, "X"),
-        (0xF71, "V"),
-        (0xF73, "M", "ཱི"),
-        (0xF74, "V"),
-        (0xF75, "M", "ཱུ"),
-        (0xF76, "M", "ྲྀ"),
-        (0xF77, "M", "ྲཱྀ"),
-        (0xF78, "M", "ླྀ"),
-        (0xF79, "M", "ླཱྀ"),
-        (0xF7A, "V"),
-        (0xF81, "M", "ཱྀ"),
-        (0xF82, "V"),
-        (0xF93, "M", "ྒྷ"),
-        (0xF94, "V"),
-        (0xF98, "X"),
-        (0xF99, "V"),
-        (0xF9D, "M", "ྜྷ"),
-        (0xF9E, "V"),
-        (0xFA2, "M", "ྡྷ"),
-        (0xFA3, "V"),
-        (0xFA7, "M", "ྦྷ"),
-        (0xFA8, "V"),
-        (0xFAC, "M", "ྫྷ"),
-        (0xFAD, "V"),
-        (0xFB9, "M", "ྐྵ"),
-        (0xFBA, "V"),
-        (0xFBD, "X"),
-        (0xFBE, "V"),
-        (0xFCD, "X"),
-        (0xFCE, "V"),
-        (0xFDB, "X"),
-        (0x1000, "V"),
-        (0x10A0, "X"),
-        (0x10C7, "M", "ⴧ"),
-        (0x10C8, "X"),
-        (0x10CD, "M", "ⴭ"),
-        (0x10CE, "X"),
-        (0x10D0, "V"),
-        (0x10FC, "M", "ნ"),
-        (0x10FD, "V"),
-        (0x115F, "X"),
-        (0x1161, "V"),
-        (0x1249, "X"),
-        (0x124A, "V"),
-        (0x124E, "X"),
-        (0x1250, "V"),
-        (0x1257, "X"),
-        (0x1258, "V"),
-        (0x1259, "X"),
-        (0x125A, "V"),
-        (0x125E, "X"),
-        (0x1260, "V"),
-        (0x1289, "X"),
-        (0x128A, "V"),
-        (0x128E, "X"),
-        (0x1290, "V"),
-        (0x12B1, "X"),
-        (0x12B2, "V"),
-        (0x12B6, "X"),
-        (0x12B8, "V"),
-        (0x12BF, "X"),
-        (0x12C0, "V"),
-        (0x12C1, "X"),
-        (0x12C2, "V"),
-        (0x12C6, "X"),
-        (0x12C8, "V"),
-        (0x12D7, "X"),
-        (0x12D8, "V"),
-        (0x1311, "X"),
-        (0x1312, "V"),
-    ]
-
-
-def _seg_14():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1316, "X"),
-        (0x1318, "V"),
-        (0x135B, "X"),
-        (0x135D, "V"),
-        (0x137D, "X"),
-        (0x1380, "V"),
-        (0x139A, "X"),
-        (0x13A0, "V"),
-        (0x13F6, "X"),
-        (0x13F8, "M", "Ᏸ"),
-        (0x13F9, "M", "Ᏹ"),
-        (0x13FA, "M", "Ᏺ"),
-        (0x13FB, "M", "Ᏻ"),
-        (0x13FC, "M", "Ᏼ"),
-        (0x13FD, "M", "Ᏽ"),
-        (0x13FE, "X"),
-        (0x1400, "V"),
-        (0x1680, "X"),
-        (0x1681, "V"),
-        (0x169D, "X"),
-        (0x16A0, "V"),
-        (0x16F9, "X"),
-        (0x1700, "V"),
-        (0x170D, "X"),
-        (0x170E, "V"),
-        (0x1715, "X"),
-        (0x1720, "V"),
-        (0x1737, "X"),
-        (0x1740, "V"),
-        (0x1754, "X"),
-        (0x1760, "V"),
-        (0x176D, "X"),
-        (0x176E, "V"),
-        (0x1771, "X"),
-        (0x1772, "V"),
-        (0x1774, "X"),
-        (0x1780, "V"),
-        (0x17B4, "X"),
-        (0x17B6, "V"),
-        (0x17DE, "X"),
-        (0x17E0, "V"),
-        (0x17EA, "X"),
-        (0x17F0, "V"),
-        (0x17FA, "X"),
-        (0x1800, "V"),
-        (0x1806, "X"),
-        (0x1807, "V"),
-        (0x180B, "I"),
-        (0x180E, "X"),
-        (0x1810, "V"),
-        (0x181A, "X"),
-        (0x1820, "V"),
-        (0x1879, "X"),
-        (0x1880, "V"),
-        (0x18AB, "X"),
-        (0x18B0, "V"),
-        (0x18F6, "X"),
-        (0x1900, "V"),
-        (0x191F, "X"),
-        (0x1920, "V"),
-        (0x192C, "X"),
-        (0x1930, "V"),
-        (0x193C, "X"),
-        (0x1940, "V"),
-        (0x1941, "X"),
-        (0x1944, "V"),
-        (0x196E, "X"),
-        (0x1970, "V"),
-        (0x1975, "X"),
-        (0x1980, "V"),
-        (0x19AC, "X"),
-        (0x19B0, "V"),
-        (0x19CA, "X"),
-        (0x19D0, "V"),
-        (0x19DB, "X"),
-        (0x19DE, "V"),
-        (0x1A1C, "X"),
-        (0x1A1E, "V"),
-        (0x1A5F, "X"),
-        (0x1A60, "V"),
-        (0x1A7D, "X"),
-        (0x1A7F, "V"),
-        (0x1A8A, "X"),
-        (0x1A90, "V"),
-        (0x1A9A, "X"),
-        (0x1AA0, "V"),
-        (0x1AAE, "X"),
-        (0x1AB0, "V"),
-        (0x1AC1, "X"),
-        (0x1B00, "V"),
-        (0x1B4C, "X"),
-        (0x1B50, "V"),
-        (0x1B7D, "X"),
-        (0x1B80, "V"),
-        (0x1BF4, "X"),
-        (0x1BFC, "V"),
-        (0x1C38, "X"),
-        (0x1C3B, "V"),
-        (0x1C4A, "X"),
-        (0x1C4D, "V"),
-    ]
-
-
-def _seg_15():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1C80, "M", "в"),
-        (0x1C81, "M", "д"),
-        (0x1C82, "M", "о"),
-        (0x1C83, "M", "с"),
-        (0x1C84, "M", "т"),
-        (0x1C86, "M", "ъ"),
-        (0x1C87, "M", "ѣ"),
-        (0x1C88, "M", "ꙋ"),
-        (0x1C89, "X"),
-        (0x1C90, "M", "ა"),
-        (0x1C91, "M", "ბ"),
-        (0x1C92, "M", "გ"),
-        (0x1C93, "M", "დ"),
-        (0x1C94, "M", "ე"),
-        (0x1C95, "M", "ვ"),
-        (0x1C96, "M", "ზ"),
-        (0x1C97, "M", "თ"),
-        (0x1C98, "M", "ი"),
-        (0x1C99, "M", "კ"),
-        (0x1C9A, "M", "ლ"),
-        (0x1C9B, "M", "მ"),
-        (0x1C9C, "M", "ნ"),
-        (0x1C9D, "M", "ო"),
-        (0x1C9E, "M", "პ"),
-        (0x1C9F, "M", "ჟ"),
-        (0x1CA0, "M", "რ"),
-        (0x1CA1, "M", "ს"),
-        (0x1CA2, "M", "ტ"),
-        (0x1CA3, "M", "უ"),
-        (0x1CA4, "M", "ფ"),
-        (0x1CA5, "M", "ქ"),
-        (0x1CA6, "M", "ღ"),
-        (0x1CA7, "M", "ყ"),
-        (0x1CA8, "M", "შ"),
-        (0x1CA9, "M", "ჩ"),
-        (0x1CAA, "M", "ც"),
-        (0x1CAB, "M", "ძ"),
-        (0x1CAC, "M", "წ"),
-        (0x1CAD, "M", "ჭ"),
-        (0x1CAE, "M", "ხ"),
-        (0x1CAF, "M", "ჯ"),
-        (0x1CB0, "M", "ჰ"),
-        (0x1CB1, "M", "ჱ"),
-        (0x1CB2, "M", "ჲ"),
-        (0x1CB3, "M", "ჳ"),
-        (0x1CB4, "M", "ჴ"),
-        (0x1CB5, "M", "ჵ"),
-        (0x1CB6, "M", "ჶ"),
-        (0x1CB7, "M", "ჷ"),
-        (0x1CB8, "M", "ჸ"),
-        (0x1CB9, "M", "ჹ"),
-        (0x1CBA, "M", "ჺ"),
-        (0x1CBB, "X"),
-        (0x1CBD, "M", "ჽ"),
-        (0x1CBE, "M", "ჾ"),
-        (0x1CBF, "M", "ჿ"),
-        (0x1CC0, "V"),
-        (0x1CC8, "X"),
-        (0x1CD0, "V"),
-        (0x1CFB, "X"),
-        (0x1D00, "V"),
-        (0x1D2C, "M", "a"),
-        (0x1D2D, "M", "æ"),
-        (0x1D2E, "M", "b"),
-        (0x1D2F, "V"),
-        (0x1D30, "M", "d"),
-        (0x1D31, "M", "e"),
-        (0x1D32, "M", "ǝ"),
-        (0x1D33, "M", "g"),
-        (0x1D34, "M", "h"),
-        (0x1D35, "M", "i"),
-        (0x1D36, "M", "j"),
-        (0x1D37, "M", "k"),
-        (0x1D38, "M", "l"),
-        (0x1D39, "M", "m"),
-        (0x1D3A, "M", "n"),
-        (0x1D3B, "V"),
-        (0x1D3C, "M", "o"),
-        (0x1D3D, "M", "ȣ"),
-        (0x1D3E, "M", "p"),
-        (0x1D3F, "M", "r"),
-        (0x1D40, "M", "t"),
-        (0x1D41, "M", "u"),
-        (0x1D42, "M", "w"),
-        (0x1D43, "M", "a"),
-        (0x1D44, "M", "ɐ"),
-        (0x1D45, "M", "ɑ"),
-        (0x1D46, "M", "ᴂ"),
-        (0x1D47, "M", "b"),
-        (0x1D48, "M", "d"),
-        (0x1D49, "M", "e"),
-        (0x1D4A, "M", "ə"),
-        (0x1D4B, "M", "ɛ"),
-        (0x1D4C, "M", "ɜ"),
-        (0x1D4D, "M", "g"),
-        (0x1D4E, "V"),
-        (0x1D4F, "M", "k"),
-        (0x1D50, "M", "m"),
-        (0x1D51, "M", "ŋ"),
-        (0x1D52, "M", "o"),
-    ]
-
-
-def _seg_16():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D53, "M", "ɔ"),
-        (0x1D54, "M", "ᴖ"),
-        (0x1D55, "M", "ᴗ"),
-        (0x1D56, "M", "p"),
-        (0x1D57, "M", "t"),
-        (0x1D58, "M", "u"),
-        (0x1D59, "M", "ᴝ"),
-        (0x1D5A, "M", "ɯ"),
-        (0x1D5B, "M", "v"),
-        (0x1D5C, "M", "ᴥ"),
-        (0x1D5D, "M", "β"),
-        (0x1D5E, "M", "γ"),
-        (0x1D5F, "M", "δ"),
-        (0x1D60, "M", "φ"),
-        (0x1D61, "M", "χ"),
-        (0x1D62, "M", "i"),
-        (0x1D63, "M", "r"),
-        (0x1D64, "M", "u"),
-        (0x1D65, "M", "v"),
-        (0x1D66, "M", "β"),
-        (0x1D67, "M", "γ"),
-        (0x1D68, "M", "ρ"),
-        (0x1D69, "M", "φ"),
-        (0x1D6A, "M", "χ"),
-        (0x1D6B, "V"),
-        (0x1D78, "M", "н"),
-        (0x1D79, "V"),
-        (0x1D9B, "M", "ɒ"),
-        (0x1D9C, "M", "c"),
-        (0x1D9D, "M", "ɕ"),
-        (0x1D9E, "M", "ð"),
-        (0x1D9F, "M", "ɜ"),
-        (0x1DA0, "M", "f"),
-        (0x1DA1, "M", "ɟ"),
-        (0x1DA2, "M", "ɡ"),
-        (0x1DA3, "M", "ɥ"),
-        (0x1DA4, "M", "ɨ"),
-        (0x1DA5, "M", "ɩ"),
-        (0x1DA6, "M", "ɪ"),
-        (0x1DA7, "M", "ᵻ"),
-        (0x1DA8, "M", "ʝ"),
-        (0x1DA9, "M", "ɭ"),
-        (0x1DAA, "M", "ᶅ"),
-        (0x1DAB, "M", "ʟ"),
-        (0x1DAC, "M", "ɱ"),
-        (0x1DAD, "M", "ɰ"),
-        (0x1DAE, "M", "ɲ"),
-        (0x1DAF, "M", "ɳ"),
-        (0x1DB0, "M", "ɴ"),
-        (0x1DB1, "M", "ɵ"),
-        (0x1DB2, "M", "ɸ"),
-        (0x1DB3, "M", "ʂ"),
-        (0x1DB4, "M", "ʃ"),
-        (0x1DB5, "M", "ƫ"),
-        (0x1DB6, "M", "ʉ"),
-        (0x1DB7, "M", "ʊ"),
-        (0x1DB8, "M", "ᴜ"),
-        (0x1DB9, "M", "ʋ"),
-        (0x1DBA, "M", "ʌ"),
-        (0x1DBB, "M", "z"),
-        (0x1DBC, "M", "ʐ"),
-        (0x1DBD, "M", "ʑ"),
-        (0x1DBE, "M", "ʒ"),
-        (0x1DBF, "M", "θ"),
-        (0x1DC0, "V"),
-        (0x1DFA, "X"),
-        (0x1DFB, "V"),
-        (0x1E00, "M", "ḁ"),
-        (0x1E01, "V"),
-        (0x1E02, "M", "ḃ"),
-        (0x1E03, "V"),
-        (0x1E04, "M", "ḅ"),
-        (0x1E05, "V"),
-        (0x1E06, "M", "ḇ"),
-        (0x1E07, "V"),
-        (0x1E08, "M", "ḉ"),
-        (0x1E09, "V"),
-        (0x1E0A, "M", "ḋ"),
-        (0x1E0B, "V"),
-        (0x1E0C, "M", "ḍ"),
-        (0x1E0D, "V"),
-        (0x1E0E, "M", "ḏ"),
-        (0x1E0F, "V"),
-        (0x1E10, "M", "ḑ"),
-        (0x1E11, "V"),
-        (0x1E12, "M", "ḓ"),
-        (0x1E13, "V"),
-        (0x1E14, "M", "ḕ"),
-        (0x1E15, "V"),
-        (0x1E16, "M", "ḗ"),
-        (0x1E17, "V"),
-        (0x1E18, "M", "ḙ"),
-        (0x1E19, "V"),
-        (0x1E1A, "M", "ḛ"),
-        (0x1E1B, "V"),
-        (0x1E1C, "M", "ḝ"),
-        (0x1E1D, "V"),
-        (0x1E1E, "M", "ḟ"),
-        (0x1E1F, "V"),
-        (0x1E20, "M", "ḡ"),
-    ]
-
-
-def _seg_17():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1E21, "V"),
-        (0x1E22, "M", "ḣ"),
-        (0x1E23, "V"),
-        (0x1E24, "M", "ḥ"),
-        (0x1E25, "V"),
-        (0x1E26, "M", "ḧ"),
-        (0x1E27, "V"),
-        (0x1E28, "M", "ḩ"),
-        (0x1E29, "V"),
-        (0x1E2A, "M", "ḫ"),
-        (0x1E2B, "V"),
-        (0x1E2C, "M", "ḭ"),
-        (0x1E2D, "V"),
-        (0x1E2E, "M", "ḯ"),
-        (0x1E2F, "V"),
-        (0x1E30, "M", "ḱ"),
-        (0x1E31, "V"),
-        (0x1E32, "M", "ḳ"),
-        (0x1E33, "V"),
-        (0x1E34, "M", "ḵ"),
-        (0x1E35, "V"),
-        (0x1E36, "M", "ḷ"),
-        (0x1E37, "V"),
-        (0x1E38, "M", "ḹ"),
-        (0x1E39, "V"),
-        (0x1E3A, "M", "ḻ"),
-        (0x1E3B, "V"),
-        (0x1E3C, "M", "ḽ"),
-        (0x1E3D, "V"),
-        (0x1E3E, "M", "ḿ"),
-        (0x1E3F, "V"),
-        (0x1E40, "M", "ṁ"),
-        (0x1E41, "V"),
-        (0x1E42, "M", "ṃ"),
-        (0x1E43, "V"),
-        (0x1E44, "M", "ṅ"),
-        (0x1E45, "V"),
-        (0x1E46, "M", "ṇ"),
-        (0x1E47, "V"),
-        (0x1E48, "M", "ṉ"),
-        (0x1E49, "V"),
-        (0x1E4A, "M", "ṋ"),
-        (0x1E4B, "V"),
-        (0x1E4C, "M", "ṍ"),
-        (0x1E4D, "V"),
-        (0x1E4E, "M", "ṏ"),
-        (0x1E4F, "V"),
-        (0x1E50, "M", "ṑ"),
-        (0x1E51, "V"),
-        (0x1E52, "M", "ṓ"),
-        (0x1E53, "V"),
-        (0x1E54, "M", "ṕ"),
-        (0x1E55, "V"),
-        (0x1E56, "M", "ṗ"),
-        (0x1E57, "V"),
-        (0x1E58, "M", "ṙ"),
-        (0x1E59, "V"),
-        (0x1E5A, "M", "ṛ"),
-        (0x1E5B, "V"),
-        (0x1E5C, "M", "ṝ"),
-        (0x1E5D, "V"),
-        (0x1E5E, "M", "ṟ"),
-        (0x1E5F, "V"),
-        (0x1E60, "M", "ṡ"),
-        (0x1E61, "V"),
-        (0x1E62, "M", "ṣ"),
-        (0x1E63, "V"),
-        (0x1E64, "M", "ṥ"),
-        (0x1E65, "V"),
-        (0x1E66, "M", "ṧ"),
-        (0x1E67, "V"),
-        (0x1E68, "M", "ṩ"),
-        (0x1E69, "V"),
-        (0x1E6A, "M", "ṫ"),
-        (0x1E6B, "V"),
-        (0x1E6C, "M", "ṭ"),
-        (0x1E6D, "V"),
-        (0x1E6E, "M", "ṯ"),
-        (0x1E6F, "V"),
-        (0x1E70, "M", "ṱ"),
-        (0x1E71, "V"),
-        (0x1E72, "M", "ṳ"),
-        (0x1E73, "V"),
-        (0x1E74, "M", "ṵ"),
-        (0x1E75, "V"),
-        (0x1E76, "M", "ṷ"),
-        (0x1E77, "V"),
-        (0x1E78, "M", "ṹ"),
-        (0x1E79, "V"),
-        (0x1E7A, "M", "ṻ"),
-        (0x1E7B, "V"),
-        (0x1E7C, "M", "ṽ"),
-        (0x1E7D, "V"),
-        (0x1E7E, "M", "ṿ"),
-        (0x1E7F, "V"),
-        (0x1E80, "M", "ẁ"),
-        (0x1E81, "V"),
-        (0x1E82, "M", "ẃ"),
-        (0x1E83, "V"),
-        (0x1E84, "M", "ẅ"),
-    ]
-
-
-def _seg_18():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1E85, "V"),
-        (0x1E86, "M", "ẇ"),
-        (0x1E87, "V"),
-        (0x1E88, "M", "ẉ"),
-        (0x1E89, "V"),
-        (0x1E8A, "M", "ẋ"),
-        (0x1E8B, "V"),
-        (0x1E8C, "M", "ẍ"),
-        (0x1E8D, "V"),
-        (0x1E8E, "M", "ẏ"),
-        (0x1E8F, "V"),
-        (0x1E90, "M", "ẑ"),
-        (0x1E91, "V"),
-        (0x1E92, "M", "ẓ"),
-        (0x1E93, "V"),
-        (0x1E94, "M", "ẕ"),
-        (0x1E95, "V"),
-        (0x1E9A, "M", "aʾ"),
-        (0x1E9B, "M", "ṡ"),
-        (0x1E9C, "V"),
-        (0x1E9E, "M", "ss"),
-        (0x1E9F, "V"),
-        (0x1EA0, "M", "ạ"),
-        (0x1EA1, "V"),
-        (0x1EA2, "M", "ả"),
-        (0x1EA3, "V"),
-        (0x1EA4, "M", "ấ"),
-        (0x1EA5, "V"),
-        (0x1EA6, "M", "ầ"),
-        (0x1EA7, "V"),
-        (0x1EA8, "M", "ẩ"),
-        (0x1EA9, "V"),
-        (0x1EAA, "M", "ẫ"),
-        (0x1EAB, "V"),
-        (0x1EAC, "M", "ậ"),
-        (0x1EAD, "V"),
-        (0x1EAE, "M", "ắ"),
-        (0x1EAF, "V"),
-        (0x1EB0, "M", "ằ"),
-        (0x1EB1, "V"),
-        (0x1EB2, "M", "ẳ"),
-        (0x1EB3, "V"),
-        (0x1EB4, "M", "ẵ"),
-        (0x1EB5, "V"),
-        (0x1EB6, "M", "ặ"),
-        (0x1EB7, "V"),
-        (0x1EB8, "M", "ẹ"),
-        (0x1EB9, "V"),
-        (0x1EBA, "M", "ẻ"),
-        (0x1EBB, "V"),
-        (0x1EBC, "M", "ẽ"),
-        (0x1EBD, "V"),
-        (0x1EBE, "M", "ế"),
-        (0x1EBF, "V"),
-        (0x1EC0, "M", "ề"),
-        (0x1EC1, "V"),
-        (0x1EC2, "M", "ể"),
-        (0x1EC3, "V"),
-        (0x1EC4, "M", "ễ"),
-        (0x1EC5, "V"),
-        (0x1EC6, "M", "ệ"),
-        (0x1EC7, "V"),
-        (0x1EC8, "M", "ỉ"),
-        (0x1EC9, "V"),
-        (0x1ECA, "M", "ị"),
-        (0x1ECB, "V"),
-        (0x1ECC, "M", "ọ"),
-        (0x1ECD, "V"),
-        (0x1ECE, "M", "ỏ"),
-        (0x1ECF, "V"),
-        (0x1ED0, "M", "ố"),
-        (0x1ED1, "V"),
-        (0x1ED2, "M", "ồ"),
-        (0x1ED3, "V"),
-        (0x1ED4, "M", "ổ"),
-        (0x1ED5, "V"),
-        (0x1ED6, "M", "ỗ"),
-        (0x1ED7, "V"),
-        (0x1ED8, "M", "ộ"),
-        (0x1ED9, "V"),
-        (0x1EDA, "M", "ớ"),
-        (0x1EDB, "V"),
-        (0x1EDC, "M", "ờ"),
-        (0x1EDD, "V"),
-        (0x1EDE, "M", "ở"),
-        (0x1EDF, "V"),
-        (0x1EE0, "M", "ỡ"),
-        (0x1EE1, "V"),
-        (0x1EE2, "M", "ợ"),
-        (0x1EE3, "V"),
-        (0x1EE4, "M", "ụ"),
-        (0x1EE5, "V"),
-        (0x1EE6, "M", "ủ"),
-        (0x1EE7, "V"),
-        (0x1EE8, "M", "ứ"),
-        (0x1EE9, "V"),
-        (0x1EEA, "M", "ừ"),
-        (0x1EEB, "V"),
-        (0x1EEC, "M", "ử"),
-        (0x1EED, "V"),
-    ]
-
-
-def _seg_19():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1EEE, "M", "ữ"),
-        (0x1EEF, "V"),
-        (0x1EF0, "M", "ự"),
-        (0x1EF1, "V"),
-        (0x1EF2, "M", "ỳ"),
-        (0x1EF3, "V"),
-        (0x1EF4, "M", "ỵ"),
-        (0x1EF5, "V"),
-        (0x1EF6, "M", "ỷ"),
-        (0x1EF7, "V"),
-        (0x1EF8, "M", "ỹ"),
-        (0x1EF9, "V"),
-        (0x1EFA, "M", "ỻ"),
-        (0x1EFB, "V"),
-        (0x1EFC, "M", "ỽ"),
-        (0x1EFD, "V"),
-        (0x1EFE, "M", "ỿ"),
-        (0x1EFF, "V"),
-        (0x1F08, "M", "ἀ"),
-        (0x1F09, "M", "ἁ"),
-        (0x1F0A, "M", "ἂ"),
-        (0x1F0B, "M", "ἃ"),
-        (0x1F0C, "M", "ἄ"),
-        (0x1F0D, "M", "ἅ"),
-        (0x1F0E, "M", "ἆ"),
-        (0x1F0F, "M", "ἇ"),
-        (0x1F10, "V"),
-        (0x1F16, "X"),
-        (0x1F18, "M", "ἐ"),
-        (0x1F19, "M", "ἑ"),
-        (0x1F1A, "M", "ἒ"),
-        (0x1F1B, "M", "ἓ"),
-        (0x1F1C, "M", "ἔ"),
-        (0x1F1D, "M", "ἕ"),
-        (0x1F1E, "X"),
-        (0x1F20, "V"),
-        (0x1F28, "M", "ἠ"),
-        (0x1F29, "M", "ἡ"),
-        (0x1F2A, "M", "ἢ"),
-        (0x1F2B, "M", "ἣ"),
-        (0x1F2C, "M", "ἤ"),
-        (0x1F2D, "M", "ἥ"),
-        (0x1F2E, "M", "ἦ"),
-        (0x1F2F, "M", "ἧ"),
-        (0x1F30, "V"),
-        (0x1F38, "M", "ἰ"),
-        (0x1F39, "M", "ἱ"),
-        (0x1F3A, "M", "ἲ"),
-        (0x1F3B, "M", "ἳ"),
-        (0x1F3C, "M", "ἴ"),
-        (0x1F3D, "M", "ἵ"),
-        (0x1F3E, "M", "ἶ"),
-        (0x1F3F, "M", "ἷ"),
-        (0x1F40, "V"),
-        (0x1F46, "X"),
-        (0x1F48, "M", "ὀ"),
-        (0x1F49, "M", "ὁ"),
-        (0x1F4A, "M", "ὂ"),
-        (0x1F4B, "M", "ὃ"),
-        (0x1F4C, "M", "ὄ"),
-        (0x1F4D, "M", "ὅ"),
-        (0x1F4E, "X"),
-        (0x1F50, "V"),
-        (0x1F58, "X"),
-        (0x1F59, "M", "ὑ"),
-        (0x1F5A, "X"),
-        (0x1F5B, "M", "ὓ"),
-        (0x1F5C, "X"),
-        (0x1F5D, "M", "ὕ"),
-        (0x1F5E, "X"),
-        (0x1F5F, "M", "ὗ"),
-        (0x1F60, "V"),
-        (0x1F68, "M", "ὠ"),
-        (0x1F69, "M", "ὡ"),
-        (0x1F6A, "M", "ὢ"),
-        (0x1F6B, "M", "ὣ"),
-        (0x1F6C, "M", "ὤ"),
-        (0x1F6D, "M", "ὥ"),
-        (0x1F6E, "M", "ὦ"),
-        (0x1F6F, "M", "ὧ"),
-        (0x1F70, "V"),
-        (0x1F71, "M", "ά"),
-        (0x1F72, "V"),
-        (0x1F73, "M", "έ"),
-        (0x1F74, "V"),
-        (0x1F75, "M", "ή"),
-        (0x1F76, "V"),
-        (0x1F77, "M", "ί"),
-        (0x1F78, "V"),
-        (0x1F79, "M", "ό"),
-        (0x1F7A, "V"),
-        (0x1F7B, "M", "ύ"),
-        (0x1F7C, "V"),
-        (0x1F7D, "M", "ώ"),
-        (0x1F7E, "X"),
-        (0x1F80, "M", "ἀι"),
-        (0x1F81, "M", "ἁι"),
-        (0x1F82, "M", "ἂι"),
-        (0x1F83, "M", "ἃι"),
-        (0x1F84, "M", "ἄι"),
-    ]
-
-
-def _seg_20():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1F85, "M", "ἅι"),
-        (0x1F86, "M", "ἆι"),
-        (0x1F87, "M", "ἇι"),
-        (0x1F88, "M", "ἀι"),
-        (0x1F89, "M", "ἁι"),
-        (0x1F8A, "M", "ἂι"),
-        (0x1F8B, "M", "ἃι"),
-        (0x1F8C, "M", "ἄι"),
-        (0x1F8D, "M", "ἅι"),
-        (0x1F8E, "M", "ἆι"),
-        (0x1F8F, "M", "ἇι"),
-        (0x1F90, "M", "ἠι"),
-        (0x1F91, "M", "ἡι"),
-        (0x1F92, "M", "ἢι"),
-        (0x1F93, "M", "ἣι"),
-        (0x1F94, "M", "ἤι"),
-        (0x1F95, "M", "ἥι"),
-        (0x1F96, "M", "ἦι"),
-        (0x1F97, "M", "ἧι"),
-        (0x1F98, "M", "ἠι"),
-        (0x1F99, "M", "ἡι"),
-        (0x1F9A, "M", "ἢι"),
-        (0x1F9B, "M", "ἣι"),
-        (0x1F9C, "M", "ἤι"),
-        (0x1F9D, "M", "ἥι"),
-        (0x1F9E, "M", "ἦι"),
-        (0x1F9F, "M", "ἧι"),
-        (0x1FA0, "M", "ὠι"),
-        (0x1FA1, "M", "ὡι"),
-        (0x1FA2, "M", "ὢι"),
-        (0x1FA3, "M", "ὣι"),
-        (0x1FA4, "M", "ὤι"),
-        (0x1FA5, "M", "ὥι"),
-        (0x1FA6, "M", "ὦι"),
-        (0x1FA7, "M", "ὧι"),
-        (0x1FA8, "M", "ὠι"),
-        (0x1FA9, "M", "ὡι"),
-        (0x1FAA, "M", "ὢι"),
-        (0x1FAB, "M", "ὣι"),
-        (0x1FAC, "M", "ὤι"),
-        (0x1FAD, "M", "ὥι"),
-        (0x1FAE, "M", "ὦι"),
-        (0x1FAF, "M", "ὧι"),
-        (0x1FB0, "V"),
-        (0x1FB2, "M", "ὰι"),
-        (0x1FB3, "M", "αι"),
-        (0x1FB4, "M", "άι"),
-        (0x1FB5, "X"),
-        (0x1FB6, "V"),
-        (0x1FB7, "M", "ᾶι"),
-        (0x1FB8, "M", "ᾰ"),
-        (0x1FB9, "M", "ᾱ"),
-        (0x1FBA, "M", "ὰ"),
-        (0x1FBB, "M", "ά"),
-        (0x1FBC, "M", "αι"),
-        (0x1FBD, "3", " ̓"),
-        (0x1FBE, "M", "ι"),
-        (0x1FBF, "3", " ̓"),
-        (0x1FC0, "3", " ͂"),
-        (0x1FC1, "3", " ̈͂"),
-        (0x1FC2, "M", "ὴι"),
-        (0x1FC3, "M", "ηι"),
-        (0x1FC4, "M", "ήι"),
-        (0x1FC5, "X"),
-        (0x1FC6, "V"),
-        (0x1FC7, "M", "ῆι"),
-        (0x1FC8, "M", "ὲ"),
-        (0x1FC9, "M", "έ"),
-        (0x1FCA, "M", "ὴ"),
-        (0x1FCB, "M", "ή"),
-        (0x1FCC, "M", "ηι"),
-        (0x1FCD, "3", " ̓̀"),
-        (0x1FCE, "3", " ̓́"),
-        (0x1FCF, "3", " ̓͂"),
-        (0x1FD0, "V"),
-        (0x1FD3, "M", "ΐ"),
-        (0x1FD4, "X"),
-        (0x1FD6, "V"),
-        (0x1FD8, "M", "ῐ"),
-        (0x1FD9, "M", "ῑ"),
-        (0x1FDA, "M", "ὶ"),
-        (0x1FDB, "M", "ί"),
-        (0x1FDC, "X"),
-        (0x1FDD, "3", " ̔̀"),
-        (0x1FDE, "3", " ̔́"),
-        (0x1FDF, "3", " ̔͂"),
-        (0x1FE0, "V"),
-        (0x1FE3, "M", "ΰ"),
-        (0x1FE4, "V"),
-        (0x1FE8, "M", "ῠ"),
-        (0x1FE9, "M", "ῡ"),
-        (0x1FEA, "M", "ὺ"),
-        (0x1FEB, "M", "ύ"),
-        (0x1FEC, "M", "ῥ"),
-        (0x1FED, "3", " ̈̀"),
-        (0x1FEE, "3", " ̈́"),
-        (0x1FEF, "3", "`"),
-        (0x1FF0, "X"),
-        (0x1FF2, "M", "ὼι"),
-        (0x1FF3, "M", "ωι"),
-    ]
-
-
-def _seg_21():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1FF4, "M", "ώι"),
-        (0x1FF5, "X"),
-        (0x1FF6, "V"),
-        (0x1FF7, "M", "ῶι"),
-        (0x1FF8, "M", "ὸ"),
-        (0x1FF9, "M", "ό"),
-        (0x1FFA, "M", "ὼ"),
-        (0x1FFB, "M", "ώ"),
-        (0x1FFC, "M", "ωι"),
-        (0x1FFD, "3", " ́"),
-        (0x1FFE, "3", " ̔"),
-        (0x1FFF, "X"),
-        (0x2000, "3", " "),
-        (0x200B, "I"),
-        (0x200C, "D", ""),
-        (0x200E, "X"),
-        (0x2010, "V"),
-        (0x2011, "M", "‐"),
-        (0x2012, "V"),
-        (0x2017, "3", " ̳"),
-        (0x2018, "V"),
-        (0x2024, "X"),
-        (0x2027, "V"),
-        (0x2028, "X"),
-        (0x202F, "3", " "),
-        (0x2030, "V"),
-        (0x2033, "M", "′′"),
-        (0x2034, "M", "′′′"),
-        (0x2035, "V"),
-        (0x2036, "M", "‵‵"),
-        (0x2037, "M", "‵‵‵"),
-        (0x2038, "V"),
-        (0x203C, "3", "!!"),
-        (0x203D, "V"),
-        (0x203E, "3", " ̅"),
-        (0x203F, "V"),
-        (0x2047, "3", "??"),
-        (0x2048, "3", "?!"),
-        (0x2049, "3", "!?"),
-        (0x204A, "V"),
-        (0x2057, "M", "′′′′"),
-        (0x2058, "V"),
-        (0x205F, "3", " "),
-        (0x2060, "I"),
-        (0x2061, "X"),
-        (0x2064, "I"),
-        (0x2065, "X"),
-        (0x2070, "M", "0"),
-        (0x2071, "M", "i"),
-        (0x2072, "X"),
-        (0x2074, "M", "4"),
-        (0x2075, "M", "5"),
-        (0x2076, "M", "6"),
-        (0x2077, "M", "7"),
-        (0x2078, "M", "8"),
-        (0x2079, "M", "9"),
-        (0x207A, "3", "+"),
-        (0x207B, "M", "−"),
-        (0x207C, "3", "="),
-        (0x207D, "3", "("),
-        (0x207E, "3", ")"),
-        (0x207F, "M", "n"),
-        (0x2080, "M", "0"),
-        (0x2081, "M", "1"),
-        (0x2082, "M", "2"),
-        (0x2083, "M", "3"),
-        (0x2084, "M", "4"),
-        (0x2085, "M", "5"),
-        (0x2086, "M", "6"),
-        (0x2087, "M", "7"),
-        (0x2088, "M", "8"),
-        (0x2089, "M", "9"),
-        (0x208A, "3", "+"),
-        (0x208B, "M", "−"),
-        (0x208C, "3", "="),
-        (0x208D, "3", "("),
-        (0x208E, "3", ")"),
-        (0x208F, "X"),
-        (0x2090, "M", "a"),
-        (0x2091, "M", "e"),
-        (0x2092, "M", "o"),
-        (0x2093, "M", "x"),
-        (0x2094, "M", "ə"),
-        (0x2095, "M", "h"),
-        (0x2096, "M", "k"),
-        (0x2097, "M", "l"),
-        (0x2098, "M", "m"),
-        (0x2099, "M", "n"),
-        (0x209A, "M", "p"),
-        (0x209B, "M", "s"),
-        (0x209C, "M", "t"),
-        (0x209D, "X"),
-        (0x20A0, "V"),
-        (0x20A8, "M", "rs"),
-        (0x20A9, "V"),
-        (0x20C0, "X"),
-        (0x20D0, "V"),
-        (0x20F1, "X"),
-        (0x2100, "3", "a/c"),
-        (0x2101, "3", "a/s"),
-    ]
-
-
-def _seg_22():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2102, "M", "c"),
-        (0x2103, "M", "°c"),
-        (0x2104, "V"),
-        (0x2105, "3", "c/o"),
-        (0x2106, "3", "c/u"),
-        (0x2107, "M", "ɛ"),
-        (0x2108, "V"),
-        (0x2109, "M", "°f"),
-        (0x210A, "M", "g"),
-        (0x210B, "M", "h"),
-        (0x210F, "M", "ħ"),
-        (0x2110, "M", "i"),
-        (0x2112, "M", "l"),
-        (0x2114, "V"),
-        (0x2115, "M", "n"),
-        (0x2116, "M", "no"),
-        (0x2117, "V"),
-        (0x2119, "M", "p"),
-        (0x211A, "M", "q"),
-        (0x211B, "M", "r"),
-        (0x211E, "V"),
-        (0x2120, "M", "sm"),
-        (0x2121, "M", "tel"),
-        (0x2122, "M", "tm"),
-        (0x2123, "V"),
-        (0x2124, "M", "z"),
-        (0x2125, "V"),
-        (0x2126, "M", "ω"),
-        (0x2127, "V"),
-        (0x2128, "M", "z"),
-        (0x2129, "V"),
-        (0x212A, "M", "k"),
-        (0x212B, "M", "å"),
-        (0x212C, "M", "b"),
-        (0x212D, "M", "c"),
-        (0x212E, "V"),
-        (0x212F, "M", "e"),
-        (0x2131, "M", "f"),
-        (0x2132, "X"),
-        (0x2133, "M", "m"),
-        (0x2134, "M", "o"),
-        (0x2135, "M", "א"),
-        (0x2136, "M", "ב"),
-        (0x2137, "M", "ג"),
-        (0x2138, "M", "ד"),
-        (0x2139, "M", "i"),
-        (0x213A, "V"),
-        (0x213B, "M", "fax"),
-        (0x213C, "M", "π"),
-        (0x213D, "M", "γ"),
-        (0x213F, "M", "π"),
-        (0x2140, "M", "∑"),
-        (0x2141, "V"),
-        (0x2145, "M", "d"),
-        (0x2147, "M", "e"),
-        (0x2148, "M", "i"),
-        (0x2149, "M", "j"),
-        (0x214A, "V"),
-        (0x2150, "M", "1⁄7"),
-        (0x2151, "M", "1⁄9"),
-        (0x2152, "M", "1⁄10"),
-        (0x2153, "M", "1⁄3"),
-        (0x2154, "M", "2⁄3"),
-        (0x2155, "M", "1⁄5"),
-        (0x2156, "M", "2⁄5"),
-        (0x2157, "M", "3⁄5"),
-        (0x2158, "M", "4⁄5"),
-        (0x2159, "M", "1⁄6"),
-        (0x215A, "M", "5⁄6"),
-        (0x215B, "M", "1⁄8"),
-        (0x215C, "M", "3⁄8"),
-        (0x215D, "M", "5⁄8"),
-        (0x215E, "M", "7⁄8"),
-        (0x215F, "M", "1⁄"),
-        (0x2160, "M", "i"),
-        (0x2161, "M", "ii"),
-        (0x2162, "M", "iii"),
-        (0x2163, "M", "iv"),
-        (0x2164, "M", "v"),
-        (0x2165, "M", "vi"),
-        (0x2166, "M", "vii"),
-        (0x2167, "M", "viii"),
-        (0x2168, "M", "ix"),
-        (0x2169, "M", "x"),
-        (0x216A, "M", "xi"),
-        (0x216B, "M", "xii"),
-        (0x216C, "M", "l"),
-        (0x216D, "M", "c"),
-        (0x216E, "M", "d"),
-        (0x216F, "M", "m"),
-        (0x2170, "M", "i"),
-        (0x2171, "M", "ii"),
-        (0x2172, "M", "iii"),
-        (0x2173, "M", "iv"),
-        (0x2174, "M", "v"),
-        (0x2175, "M", "vi"),
-        (0x2176, "M", "vii"),
-        (0x2177, "M", "viii"),
-        (0x2178, "M", "ix"),
-        (0x2179, "M", "x"),
-    ]
-
-
-def _seg_23():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x217A, "M", "xi"),
-        (0x217B, "M", "xii"),
-        (0x217C, "M", "l"),
-        (0x217D, "M", "c"),
-        (0x217E, "M", "d"),
-        (0x217F, "M", "m"),
-        (0x2180, "V"),
-        (0x2183, "X"),
-        (0x2184, "V"),
-        (0x2189, "M", "0⁄3"),
-        (0x218A, "V"),
-        (0x218C, "X"),
-        (0x2190, "V"),
-        (0x222C, "M", "∫∫"),
-        (0x222D, "M", "∫∫∫"),
-        (0x222E, "V"),
-        (0x222F, "M", "∮∮"),
-        (0x2230, "M", "∮∮∮"),
-        (0x2231, "V"),
-        (0x2260, "3"),
-        (0x2261, "V"),
-        (0x226E, "3"),
-        (0x2270, "V"),
-        (0x2329, "M", "〈"),
-        (0x232A, "M", "〉"),
-        (0x232B, "V"),
-        (0x2427, "X"),
-        (0x2440, "V"),
-        (0x244B, "X"),
-        (0x2460, "M", "1"),
-        (0x2461, "M", "2"),
-        (0x2462, "M", "3"),
-        (0x2463, "M", "4"),
-        (0x2464, "M", "5"),
-        (0x2465, "M", "6"),
-        (0x2466, "M", "7"),
-        (0x2467, "M", "8"),
-        (0x2468, "M", "9"),
-        (0x2469, "M", "10"),
-        (0x246A, "M", "11"),
-        (0x246B, "M", "12"),
-        (0x246C, "M", "13"),
-        (0x246D, "M", "14"),
-        (0x246E, "M", "15"),
-        (0x246F, "M", "16"),
-        (0x2470, "M", "17"),
-        (0x2471, "M", "18"),
-        (0x2472, "M", "19"),
-        (0x2473, "M", "20"),
-        (0x2474, "3", "(1)"),
-        (0x2475, "3", "(2)"),
-        (0x2476, "3", "(3)"),
-        (0x2477, "3", "(4)"),
-        (0x2478, "3", "(5)"),
-        (0x2479, "3", "(6)"),
-        (0x247A, "3", "(7)"),
-        (0x247B, "3", "(8)"),
-        (0x247C, "3", "(9)"),
-        (0x247D, "3", "(10)"),
-        (0x247E, "3", "(11)"),
-        (0x247F, "3", "(12)"),
-        (0x2480, "3", "(13)"),
-        (0x2481, "3", "(14)"),
-        (0x2482, "3", "(15)"),
-        (0x2483, "3", "(16)"),
-        (0x2484, "3", "(17)"),
-        (0x2485, "3", "(18)"),
-        (0x2486, "3", "(19)"),
-        (0x2487, "3", "(20)"),
-        (0x2488, "X"),
-        (0x249C, "3", "(a)"),
-        (0x249D, "3", "(b)"),
-        (0x249E, "3", "(c)"),
-        (0x249F, "3", "(d)"),
-        (0x24A0, "3", "(e)"),
-        (0x24A1, "3", "(f)"),
-        (0x24A2, "3", "(g)"),
-        (0x24A3, "3", "(h)"),
-        (0x24A4, "3", "(i)"),
-        (0x24A5, "3", "(j)"),
-        (0x24A6, "3", "(k)"),
-        (0x24A7, "3", "(l)"),
-        (0x24A8, "3", "(m)"),
-        (0x24A9, "3", "(n)"),
-        (0x24AA, "3", "(o)"),
-        (0x24AB, "3", "(p)"),
-        (0x24AC, "3", "(q)"),
-        (0x24AD, "3", "(r)"),
-        (0x24AE, "3", "(s)"),
-        (0x24AF, "3", "(t)"),
-        (0x24B0, "3", "(u)"),
-        (0x24B1, "3", "(v)"),
-        (0x24B2, "3", "(w)"),
-        (0x24B3, "3", "(x)"),
-        (0x24B4, "3", "(y)"),
-        (0x24B5, "3", "(z)"),
-        (0x24B6, "M", "a"),
-        (0x24B7, "M", "b"),
-        (0x24B8, "M", "c"),
-        (0x24B9, "M", "d"),
-    ]
-
-
-def _seg_24():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x24BA, "M", "e"),
-        (0x24BB, "M", "f"),
-        (0x24BC, "M", "g"),
-        (0x24BD, "M", "h"),
-        (0x24BE, "M", "i"),
-        (0x24BF, "M", "j"),
-        (0x24C0, "M", "k"),
-        (0x24C1, "M", "l"),
-        (0x24C2, "M", "m"),
-        (0x24C3, "M", "n"),
-        (0x24C4, "M", "o"),
-        (0x24C5, "M", "p"),
-        (0x24C6, "M", "q"),
-        (0x24C7, "M", "r"),
-        (0x24C8, "M", "s"),
-        (0x24C9, "M", "t"),
-        (0x24CA, "M", "u"),
-        (0x24CB, "M", "v"),
-        (0x24CC, "M", "w"),
-        (0x24CD, "M", "x"),
-        (0x24CE, "M", "y"),
-        (0x24CF, "M", "z"),
-        (0x24D0, "M", "a"),
-        (0x24D1, "M", "b"),
-        (0x24D2, "M", "c"),
-        (0x24D3, "M", "d"),
-        (0x24D4, "M", "e"),
-        (0x24D5, "M", "f"),
-        (0x24D6, "M", "g"),
-        (0x24D7, "M", "h"),
-        (0x24D8, "M", "i"),
-        (0x24D9, "M", "j"),
-        (0x24DA, "M", "k"),
-        (0x24DB, "M", "l"),
-        (0x24DC, "M", "m"),
-        (0x24DD, "M", "n"),
-        (0x24DE, "M", "o"),
-        (0x24DF, "M", "p"),
-        (0x24E0, "M", "q"),
-        (0x24E1, "M", "r"),
-        (0x24E2, "M", "s"),
-        (0x24E3, "M", "t"),
-        (0x24E4, "M", "u"),
-        (0x24E5, "M", "v"),
-        (0x24E6, "M", "w"),
-        (0x24E7, "M", "x"),
-        (0x24E8, "M", "y"),
-        (0x24E9, "M", "z"),
-        (0x24EA, "M", "0"),
-        (0x24EB, "V"),
-        (0x2A0C, "M", "∫∫∫∫"),
-        (0x2A0D, "V"),
-        (0x2A74, "3", "::="),
-        (0x2A75, "3", "=="),
-        (0x2A76, "3", "==="),
-        (0x2A77, "V"),
-        (0x2ADC, "M", "⫝̸"),
-        (0x2ADD, "V"),
-        (0x2B74, "X"),
-        (0x2B76, "V"),
-        (0x2B96, "X"),
-        (0x2B97, "V"),
-        (0x2C00, "M", "ⰰ"),
-        (0x2C01, "M", "ⰱ"),
-        (0x2C02, "M", "ⰲ"),
-        (0x2C03, "M", "ⰳ"),
-        (0x2C04, "M", "ⰴ"),
-        (0x2C05, "M", "ⰵ"),
-        (0x2C06, "M", "ⰶ"),
-        (0x2C07, "M", "ⰷ"),
-        (0x2C08, "M", "ⰸ"),
-        (0x2C09, "M", "ⰹ"),
-        (0x2C0A, "M", "ⰺ"),
-        (0x2C0B, "M", "ⰻ"),
-        (0x2C0C, "M", "ⰼ"),
-        (0x2C0D, "M", "ⰽ"),
-        (0x2C0E, "M", "ⰾ"),
-        (0x2C0F, "M", "ⰿ"),
-        (0x2C10, "M", "ⱀ"),
-        (0x2C11, "M", "ⱁ"),
-        (0x2C12, "M", "ⱂ"),
-        (0x2C13, "M", "ⱃ"),
-        (0x2C14, "M", "ⱄ"),
-        (0x2C15, "M", "ⱅ"),
-        (0x2C16, "M", "ⱆ"),
-        (0x2C17, "M", "ⱇ"),
-        (0x2C18, "M", "ⱈ"),
-        (0x2C19, "M", "ⱉ"),
-        (0x2C1A, "M", "ⱊ"),
-        (0x2C1B, "M", "ⱋ"),
-        (0x2C1C, "M", "ⱌ"),
-        (0x2C1D, "M", "ⱍ"),
-        (0x2C1E, "M", "ⱎ"),
-        (0x2C1F, "M", "ⱏ"),
-        (0x2C20, "M", "ⱐ"),
-        (0x2C21, "M", "ⱑ"),
-        (0x2C22, "M", "ⱒ"),
-        (0x2C23, "M", "ⱓ"),
-        (0x2C24, "M", "ⱔ"),
-        (0x2C25, "M", "ⱕ"),
-    ]
-
-
-def _seg_25():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2C26, "M", "ⱖ"),
-        (0x2C27, "M", "ⱗ"),
-        (0x2C28, "M", "ⱘ"),
-        (0x2C29, "M", "ⱙ"),
-        (0x2C2A, "M", "ⱚ"),
-        (0x2C2B, "M", "ⱛ"),
-        (0x2C2C, "M", "ⱜ"),
-        (0x2C2D, "M", "ⱝ"),
-        (0x2C2E, "M", "ⱞ"),
-        (0x2C2F, "X"),
-        (0x2C30, "V"),
-        (0x2C5F, "X"),
-        (0x2C60, "M", "ⱡ"),
-        (0x2C61, "V"),
-        (0x2C62, "M", "ɫ"),
-        (0x2C63, "M", "ᵽ"),
-        (0x2C64, "M", "ɽ"),
-        (0x2C65, "V"),
-        (0x2C67, "M", "ⱨ"),
-        (0x2C68, "V"),
-        (0x2C69, "M", "ⱪ"),
-        (0x2C6A, "V"),
-        (0x2C6B, "M", "ⱬ"),
-        (0x2C6C, "V"),
-        (0x2C6D, "M", "ɑ"),
-        (0x2C6E, "M", "ɱ"),
-        (0x2C6F, "M", "ɐ"),
-        (0x2C70, "M", "ɒ"),
-        (0x2C71, "V"),
-        (0x2C72, "M", "ⱳ"),
-        (0x2C73, "V"),
-        (0x2C75, "M", "ⱶ"),
-        (0x2C76, "V"),
-        (0x2C7C, "M", "j"),
-        (0x2C7D, "M", "v"),
-        (0x2C7E, "M", "ȿ"),
-        (0x2C7F, "M", "ɀ"),
-        (0x2C80, "M", "ⲁ"),
-        (0x2C81, "V"),
-        (0x2C82, "M", "ⲃ"),
-        (0x2C83, "V"),
-        (0x2C84, "M", "ⲅ"),
-        (0x2C85, "V"),
-        (0x2C86, "M", "ⲇ"),
-        (0x2C87, "V"),
-        (0x2C88, "M", "ⲉ"),
-        (0x2C89, "V"),
-        (0x2C8A, "M", "ⲋ"),
-        (0x2C8B, "V"),
-        (0x2C8C, "M", "ⲍ"),
-        (0x2C8D, "V"),
-        (0x2C8E, "M", "ⲏ"),
-        (0x2C8F, "V"),
-        (0x2C90, "M", "ⲑ"),
-        (0x2C91, "V"),
-        (0x2C92, "M", "ⲓ"),
-        (0x2C93, "V"),
-        (0x2C94, "M", "ⲕ"),
-        (0x2C95, "V"),
-        (0x2C96, "M", "ⲗ"),
-        (0x2C97, "V"),
-        (0x2C98, "M", "ⲙ"),
-        (0x2C99, "V"),
-        (0x2C9A, "M", "ⲛ"),
-        (0x2C9B, "V"),
-        (0x2C9C, "M", "ⲝ"),
-        (0x2C9D, "V"),
-        (0x2C9E, "M", "ⲟ"),
-        (0x2C9F, "V"),
-        (0x2CA0, "M", "ⲡ"),
-        (0x2CA1, "V"),
-        (0x2CA2, "M", "ⲣ"),
-        (0x2CA3, "V"),
-        (0x2CA4, "M", "ⲥ"),
-        (0x2CA5, "V"),
-        (0x2CA6, "M", "ⲧ"),
-        (0x2CA7, "V"),
-        (0x2CA8, "M", "ⲩ"),
-        (0x2CA9, "V"),
-        (0x2CAA, "M", "ⲫ"),
-        (0x2CAB, "V"),
-        (0x2CAC, "M", "ⲭ"),
-        (0x2CAD, "V"),
-        (0x2CAE, "M", "ⲯ"),
-        (0x2CAF, "V"),
-        (0x2CB0, "M", "ⲱ"),
-        (0x2CB1, "V"),
-        (0x2CB2, "M", "ⲳ"),
-        (0x2CB3, "V"),
-        (0x2CB4, "M", "ⲵ"),
-        (0x2CB5, "V"),
-        (0x2CB6, "M", "ⲷ"),
-        (0x2CB7, "V"),
-        (0x2CB8, "M", "ⲹ"),
-        (0x2CB9, "V"),
-        (0x2CBA, "M", "ⲻ"),
-        (0x2CBB, "V"),
-        (0x2CBC, "M", "ⲽ"),
-        (0x2CBD, "V"),
-        (0x2CBE, "M", "ⲿ"),
-    ]
-
-
-def _seg_26():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2CBF, "V"),
-        (0x2CC0, "M", "ⳁ"),
-        (0x2CC1, "V"),
-        (0x2CC2, "M", "ⳃ"),
-        (0x2CC3, "V"),
-        (0x2CC4, "M", "ⳅ"),
-        (0x2CC5, "V"),
-        (0x2CC6, "M", "ⳇ"),
-        (0x2CC7, "V"),
-        (0x2CC8, "M", "ⳉ"),
-        (0x2CC9, "V"),
-        (0x2CCA, "M", "ⳋ"),
-        (0x2CCB, "V"),
-        (0x2CCC, "M", "ⳍ"),
-        (0x2CCD, "V"),
-        (0x2CCE, "M", "ⳏ"),
-        (0x2CCF, "V"),
-        (0x2CD0, "M", "ⳑ"),
-        (0x2CD1, "V"),
-        (0x2CD2, "M", "ⳓ"),
-        (0x2CD3, "V"),
-        (0x2CD4, "M", "ⳕ"),
-        (0x2CD5, "V"),
-        (0x2CD6, "M", "ⳗ"),
-        (0x2CD7, "V"),
-        (0x2CD8, "M", "ⳙ"),
-        (0x2CD9, "V"),
-        (0x2CDA, "M", "ⳛ"),
-        (0x2CDB, "V"),
-        (0x2CDC, "M", "ⳝ"),
-        (0x2CDD, "V"),
-        (0x2CDE, "M", "ⳟ"),
-        (0x2CDF, "V"),
-        (0x2CE0, "M", "ⳡ"),
-        (0x2CE1, "V"),
-        (0x2CE2, "M", "ⳣ"),
-        (0x2CE3, "V"),
-        (0x2CEB, "M", "ⳬ"),
-        (0x2CEC, "V"),
-        (0x2CED, "M", "ⳮ"),
-        (0x2CEE, "V"),
-        (0x2CF2, "M", "ⳳ"),
-        (0x2CF3, "V"),
-        (0x2CF4, "X"),
-        (0x2CF9, "V"),
-        (0x2D26, "X"),
-        (0x2D27, "V"),
-        (0x2D28, "X"),
-        (0x2D2D, "V"),
-        (0x2D2E, "X"),
-        (0x2D30, "V"),
-        (0x2D68, "X"),
-        (0x2D6F, "M", "ⵡ"),
-        (0x2D70, "V"),
-        (0x2D71, "X"),
-        (0x2D7F, "V"),
-        (0x2D97, "X"),
-        (0x2DA0, "V"),
-        (0x2DA7, "X"),
-        (0x2DA8, "V"),
-        (0x2DAF, "X"),
-        (0x2DB0, "V"),
-        (0x2DB7, "X"),
-        (0x2DB8, "V"),
-        (0x2DBF, "X"),
-        (0x2DC0, "V"),
-        (0x2DC7, "X"),
-        (0x2DC8, "V"),
-        (0x2DCF, "X"),
-        (0x2DD0, "V"),
-        (0x2DD7, "X"),
-        (0x2DD8, "V"),
-        (0x2DDF, "X"),
-        (0x2DE0, "V"),
-        (0x2E53, "X"),
-        (0x2E80, "V"),
-        (0x2E9A, "X"),
-        (0x2E9B, "V"),
-        (0x2E9F, "M", "母"),
-        (0x2EA0, "V"),
-        (0x2EF3, "M", "龟"),
-        (0x2EF4, "X"),
-        (0x2F00, "M", "一"),
-        (0x2F01, "M", "丨"),
-        (0x2F02, "M", "丶"),
-        (0x2F03, "M", "丿"),
-        (0x2F04, "M", "乙"),
-        (0x2F05, "M", "亅"),
-        (0x2F06, "M", "二"),
-        (0x2F07, "M", "亠"),
-        (0x2F08, "M", "人"),
-        (0x2F09, "M", "儿"),
-        (0x2F0A, "M", "入"),
-        (0x2F0B, "M", "八"),
-        (0x2F0C, "M", "冂"),
-        (0x2F0D, "M", "冖"),
-        (0x2F0E, "M", "冫"),
-        (0x2F0F, "M", "几"),
-        (0x2F10, "M", "凵"),
-        (0x2F11, "M", "刀"),
-    ]
-
-
-def _seg_27():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F12, "M", "力"),
-        (0x2F13, "M", "勹"),
-        (0x2F14, "M", "匕"),
-        (0x2F15, "M", "匚"),
-        (0x2F16, "M", "匸"),
-        (0x2F17, "M", "十"),
-        (0x2F18, "M", "卜"),
-        (0x2F19, "M", "卩"),
-        (0x2F1A, "M", "厂"),
-        (0x2F1B, "M", "厶"),
-        (0x2F1C, "M", "又"),
-        (0x2F1D, "M", "口"),
-        (0x2F1E, "M", "囗"),
-        (0x2F1F, "M", "土"),
-        (0x2F20, "M", "士"),
-        (0x2F21, "M", "夂"),
-        (0x2F22, "M", "夊"),
-        (0x2F23, "M", "夕"),
-        (0x2F24, "M", "大"),
-        (0x2F25, "M", "女"),
-        (0x2F26, "M", "子"),
-        (0x2F27, "M", "宀"),
-        (0x2F28, "M", "寸"),
-        (0x2F29, "M", "小"),
-        (0x2F2A, "M", "尢"),
-        (0x2F2B, "M", "尸"),
-        (0x2F2C, "M", "屮"),
-        (0x2F2D, "M", "山"),
-        (0x2F2E, "M", "巛"),
-        (0x2F2F, "M", "工"),
-        (0x2F30, "M", "己"),
-        (0x2F31, "M", "巾"),
-        (0x2F32, "M", "干"),
-        (0x2F33, "M", "幺"),
-        (0x2F34, "M", "广"),
-        (0x2F35, "M", "廴"),
-        (0x2F36, "M", "廾"),
-        (0x2F37, "M", "弋"),
-        (0x2F38, "M", "弓"),
-        (0x2F39, "M", "彐"),
-        (0x2F3A, "M", "彡"),
-        (0x2F3B, "M", "彳"),
-        (0x2F3C, "M", "心"),
-        (0x2F3D, "M", "戈"),
-        (0x2F3E, "M", "戶"),
-        (0x2F3F, "M", "手"),
-        (0x2F40, "M", "支"),
-        (0x2F41, "M", "攴"),
-        (0x2F42, "M", "文"),
-        (0x2F43, "M", "斗"),
-        (0x2F44, "M", "斤"),
-        (0x2F45, "M", "方"),
-        (0x2F46, "M", "无"),
-        (0x2F47, "M", "日"),
-        (0x2F48, "M", "曰"),
-        (0x2F49, "M", "月"),
-        (0x2F4A, "M", "木"),
-        (0x2F4B, "M", "欠"),
-        (0x2F4C, "M", "止"),
-        (0x2F4D, "M", "歹"),
-        (0x2F4E, "M", "殳"),
-        (0x2F4F, "M", "毋"),
-        (0x2F50, "M", "比"),
-        (0x2F51, "M", "毛"),
-        (0x2F52, "M", "氏"),
-        (0x2F53, "M", "气"),
-        (0x2F54, "M", "水"),
-        (0x2F55, "M", "火"),
-        (0x2F56, "M", "爪"),
-        (0x2F57, "M", "父"),
-        (0x2F58, "M", "爻"),
-        (0x2F59, "M", "爿"),
-        (0x2F5A, "M", "片"),
-        (0x2F5B, "M", "牙"),
-        (0x2F5C, "M", "牛"),
-        (0x2F5D, "M", "犬"),
-        (0x2F5E, "M", "玄"),
-        (0x2F5F, "M", "玉"),
-        (0x2F60, "M", "瓜"),
-        (0x2F61, "M", "瓦"),
-        (0x2F62, "M", "甘"),
-        (0x2F63, "M", "生"),
-        (0x2F64, "M", "用"),
-        (0x2F65, "M", "田"),
-        (0x2F66, "M", "疋"),
-        (0x2F67, "M", "疒"),
-        (0x2F68, "M", "癶"),
-        (0x2F69, "M", "白"),
-        (0x2F6A, "M", "皮"),
-        (0x2F6B, "M", "皿"),
-        (0x2F6C, "M", "目"),
-        (0x2F6D, "M", "矛"),
-        (0x2F6E, "M", "矢"),
-        (0x2F6F, "M", "石"),
-        (0x2F70, "M", "示"),
-        (0x2F71, "M", "禸"),
-        (0x2F72, "M", "禾"),
-        (0x2F73, "M", "穴"),
-        (0x2F74, "M", "立"),
-        (0x2F75, "M", "竹"),
-    ]
-
-
-def _seg_28():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F76, "M", "米"),
-        (0x2F77, "M", "糸"),
-        (0x2F78, "M", "缶"),
-        (0x2F79, "M", "网"),
-        (0x2F7A, "M", "羊"),
-        (0x2F7B, "M", "羽"),
-        (0x2F7C, "M", "老"),
-        (0x2F7D, "M", "而"),
-        (0x2F7E, "M", "耒"),
-        (0x2F7F, "M", "耳"),
-        (0x2F80, "M", "聿"),
-        (0x2F81, "M", "肉"),
-        (0x2F82, "M", "臣"),
-        (0x2F83, "M", "自"),
-        (0x2F84, "M", "至"),
-        (0x2F85, "M", "臼"),
-        (0x2F86, "M", "舌"),
-        (0x2F87, "M", "舛"),
-        (0x2F88, "M", "舟"),
-        (0x2F89, "M", "艮"),
-        (0x2F8A, "M", "色"),
-        (0x2F8B, "M", "艸"),
-        (0x2F8C, "M", "虍"),
-        (0x2F8D, "M", "虫"),
-        (0x2F8E, "M", "血"),
-        (0x2F8F, "M", "行"),
-        (0x2F90, "M", "衣"),
-        (0x2F91, "M", "襾"),
-        (0x2F92, "M", "見"),
-        (0x2F93, "M", "角"),
-        (0x2F94, "M", "言"),
-        (0x2F95, "M", "谷"),
-        (0x2F96, "M", "豆"),
-        (0x2F97, "M", "豕"),
-        (0x2F98, "M", "豸"),
-        (0x2F99, "M", "貝"),
-        (0x2F9A, "M", "赤"),
-        (0x2F9B, "M", "走"),
-        (0x2F9C, "M", "足"),
-        (0x2F9D, "M", "身"),
-        (0x2F9E, "M", "車"),
-        (0x2F9F, "M", "辛"),
-        (0x2FA0, "M", "辰"),
-        (0x2FA1, "M", "辵"),
-        (0x2FA2, "M", "邑"),
-        (0x2FA3, "M", "酉"),
-        (0x2FA4, "M", "釆"),
-        (0x2FA5, "M", "里"),
-        (0x2FA6, "M", "金"),
-        (0x2FA7, "M", "長"),
-        (0x2FA8, "M", "門"),
-        (0x2FA9, "M", "阜"),
-        (0x2FAA, "M", "隶"),
-        (0x2FAB, "M", "隹"),
-        (0x2FAC, "M", "雨"),
-        (0x2FAD, "M", "靑"),
-        (0x2FAE, "M", "非"),
-        (0x2FAF, "M", "面"),
-        (0x2FB0, "M", "革"),
-        (0x2FB1, "M", "韋"),
-        (0x2FB2, "M", "韭"),
-        (0x2FB3, "M", "音"),
-        (0x2FB4, "M", "頁"),
-        (0x2FB5, "M", "風"),
-        (0x2FB6, "M", "飛"),
-        (0x2FB7, "M", "食"),
-        (0x2FB8, "M", "首"),
-        (0x2FB9, "M", "香"),
-        (0x2FBA, "M", "馬"),
-        (0x2FBB, "M", "骨"),
-        (0x2FBC, "M", "高"),
-        (0x2FBD, "M", "髟"),
-        (0x2FBE, "M", "鬥"),
-        (0x2FBF, "M", "鬯"),
-        (0x2FC0, "M", "鬲"),
-        (0x2FC1, "M", "鬼"),
-        (0x2FC2, "M", "魚"),
-        (0x2FC3, "M", "鳥"),
-        (0x2FC4, "M", "鹵"),
-        (0x2FC5, "M", "鹿"),
-        (0x2FC6, "M", "麥"),
-        (0x2FC7, "M", "麻"),
-        (0x2FC8, "M", "黃"),
-        (0x2FC9, "M", "黍"),
-        (0x2FCA, "M", "黑"),
-        (0x2FCB, "M", "黹"),
-        (0x2FCC, "M", "黽"),
-        (0x2FCD, "M", "鼎"),
-        (0x2FCE, "M", "鼓"),
-        (0x2FCF, "M", "鼠"),
-        (0x2FD0, "M", "鼻"),
-        (0x2FD1, "M", "齊"),
-        (0x2FD2, "M", "齒"),
-        (0x2FD3, "M", "龍"),
-        (0x2FD4, "M", "龜"),
-        (0x2FD5, "M", "龠"),
-        (0x2FD6, "X"),
-        (0x3000, "3", " "),
-        (0x3001, "V"),
-        (0x3002, "M", "."),
-    ]
-
-
-def _seg_29():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x3003, "V"),
-        (0x3036, "M", "〒"),
-        (0x3037, "V"),
-        (0x3038, "M", "十"),
-        (0x3039, "M", "卄"),
-        (0x303A, "M", "卅"),
-        (0x303B, "V"),
-        (0x3040, "X"),
-        (0x3041, "V"),
-        (0x3097, "X"),
-        (0x3099, "V"),
-        (0x309B, "3", " ゙"),
-        (0x309C, "3", " ゚"),
-        (0x309D, "V"),
-        (0x309F, "M", "より"),
-        (0x30A0, "V"),
-        (0x30FF, "M", "コト"),
-        (0x3100, "X"),
-        (0x3105, "V"),
-        (0x3130, "X"),
-        (0x3131, "M", "ᄀ"),
-        (0x3132, "M", "ᄁ"),
-        (0x3133, "M", "ᆪ"),
-        (0x3134, "M", "ᄂ"),
-        (0x3135, "M", "ᆬ"),
-        (0x3136, "M", "ᆭ"),
-        (0x3137, "M", "ᄃ"),
-        (0x3138, "M", "ᄄ"),
-        (0x3139, "M", "ᄅ"),
-        (0x313A, "M", "ᆰ"),
-        (0x313B, "M", "ᆱ"),
-        (0x313C, "M", "ᆲ"),
-        (0x313D, "M", "ᆳ"),
-        (0x313E, "M", "ᆴ"),
-        (0x313F, "M", "ᆵ"),
-        (0x3140, "M", "ᄚ"),
-        (0x3141, "M", "ᄆ"),
-        (0x3142, "M", "ᄇ"),
-        (0x3143, "M", "ᄈ"),
-        (0x3144, "M", "ᄡ"),
-        (0x3145, "M", "ᄉ"),
-        (0x3146, "M", "ᄊ"),
-        (0x3147, "M", "ᄋ"),
-        (0x3148, "M", "ᄌ"),
-        (0x3149, "M", "ᄍ"),
-        (0x314A, "M", "ᄎ"),
-        (0x314B, "M", "ᄏ"),
-        (0x314C, "M", "ᄐ"),
-        (0x314D, "M", "ᄑ"),
-        (0x314E, "M", "ᄒ"),
-        (0x314F, "M", "ᅡ"),
-        (0x3150, "M", "ᅢ"),
-        (0x3151, "M", "ᅣ"),
-        (0x3152, "M", "ᅤ"),
-        (0x3153, "M", "ᅥ"),
-        (0x3154, "M", "ᅦ"),
-        (0x3155, "M", "ᅧ"),
-        (0x3156, "M", "ᅨ"),
-        (0x3157, "M", "ᅩ"),
-        (0x3158, "M", "ᅪ"),
-        (0x3159, "M", "ᅫ"),
-        (0x315A, "M", "ᅬ"),
-        (0x315B, "M", "ᅭ"),
-        (0x315C, "M", "ᅮ"),
-        (0x315D, "M", "ᅯ"),
-        (0x315E, "M", "ᅰ"),
-        (0x315F, "M", "ᅱ"),
-        (0x3160, "M", "ᅲ"),
-        (0x3161, "M", "ᅳ"),
-        (0x3162, "M", "ᅴ"),
-        (0x3163, "M", "ᅵ"),
-        (0x3164, "X"),
-        (0x3165, "M", "ᄔ"),
-        (0x3166, "M", "ᄕ"),
-        (0x3167, "M", "ᇇ"),
-        (0x3168, "M", "ᇈ"),
-        (0x3169, "M", "ᇌ"),
-        (0x316A, "M", "ᇎ"),
-        (0x316B, "M", "ᇓ"),
-        (0x316C, "M", "ᇗ"),
-        (0x316D, "M", "ᇙ"),
-        (0x316E, "M", "ᄜ"),
-        (0x316F, "M", "ᇝ"),
-        (0x3170, "M", "ᇟ"),
-        (0x3171, "M", "ᄝ"),
-        (0x3172, "M", "ᄞ"),
-        (0x3173, "M", "ᄠ"),
-        (0x3174, "M", "ᄢ"),
-        (0x3175, "M", "ᄣ"),
-        (0x3176, "M", "ᄧ"),
-        (0x3177, "M", "ᄩ"),
-        (0x3178, "M", "ᄫ"),
-        (0x3179, "M", "ᄬ"),
-        (0x317A, "M", "ᄭ"),
-        (0x317B, "M", "ᄮ"),
-        (0x317C, "M", "ᄯ"),
-        (0x317D, "M", "ᄲ"),
-        (0x317E, "M", "ᄶ"),
-        (0x317F, "M", "ᅀ"),
-        (0x3180, "M", "ᅇ"),
-    ]
-
-
-def _seg_30():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x3181, "M", "ᅌ"),
-        (0x3182, "M", "ᇱ"),
-        (0x3183, "M", "ᇲ"),
-        (0x3184, "M", "ᅗ"),
-        (0x3185, "M", "ᅘ"),
-        (0x3186, "M", "ᅙ"),
-        (0x3187, "M", "ᆄ"),
-        (0x3188, "M", "ᆅ"),
-        (0x3189, "M", "ᆈ"),
-        (0x318A, "M", "ᆑ"),
-        (0x318B, "M", "ᆒ"),
-        (0x318C, "M", "ᆔ"),
-        (0x318D, "M", "ᆞ"),
-        (0x318E, "M", "ᆡ"),
-        (0x318F, "X"),
-        (0x3190, "V"),
-        (0x3192, "M", "一"),
-        (0x3193, "M", "二"),
-        (0x3194, "M", "三"),
-        (0x3195, "M", "四"),
-        (0x3196, "M", "上"),
-        (0x3197, "M", "中"),
-        (0x3198, "M", "下"),
-        (0x3199, "M", "甲"),
-        (0x319A, "M", "乙"),
-        (0x319B, "M", "丙"),
-        (0x319C, "M", "丁"),
-        (0x319D, "M", "天"),
-        (0x319E, "M", "地"),
-        (0x319F, "M", "人"),
-        (0x31A0, "V"),
-        (0x31E4, "X"),
-        (0x31F0, "V"),
-        (0x3200, "3", "(ᄀ)"),
-        (0x3201, "3", "(ᄂ)"),
-        (0x3202, "3", "(ᄃ)"),
-        (0x3203, "3", "(ᄅ)"),
-        (0x3204, "3", "(ᄆ)"),
-        (0x3205, "3", "(ᄇ)"),
-        (0x3206, "3", "(ᄉ)"),
-        (0x3207, "3", "(ᄋ)"),
-        (0x3208, "3", "(ᄌ)"),
-        (0x3209, "3", "(ᄎ)"),
-        (0x320A, "3", "(ᄏ)"),
-        (0x320B, "3", "(ᄐ)"),
-        (0x320C, "3", "(ᄑ)"),
-        (0x320D, "3", "(ᄒ)"),
-        (0x320E, "3", "(가)"),
-        (0x320F, "3", "(나)"),
-        (0x3210, "3", "(다)"),
-        (0x3211, "3", "(라)"),
-        (0x3212, "3", "(마)"),
-        (0x3213, "3", "(바)"),
-        (0x3214, "3", "(사)"),
-        (0x3215, "3", "(아)"),
-        (0x3216, "3", "(자)"),
-        (0x3217, "3", "(차)"),
-        (0x3218, "3", "(카)"),
-        (0x3219, "3", "(타)"),
-        (0x321A, "3", "(파)"),
-        (0x321B, "3", "(하)"),
-        (0x321C, "3", "(주)"),
-        (0x321D, "3", "(오전)"),
-        (0x321E, "3", "(오후)"),
-        (0x321F, "X"),
-        (0x3220, "3", "(一)"),
-        (0x3221, "3", "(二)"),
-        (0x3222, "3", "(三)"),
-        (0x3223, "3", "(四)"),
-        (0x3224, "3", "(五)"),
-        (0x3225, "3", "(六)"),
-        (0x3226, "3", "(七)"),
-        (0x3227, "3", "(八)"),
-        (0x3228, "3", "(九)"),
-        (0x3229, "3", "(十)"),
-        (0x322A, "3", "(月)"),
-        (0x322B, "3", "(火)"),
-        (0x322C, "3", "(水)"),
-        (0x322D, "3", "(木)"),
-        (0x322E, "3", "(金)"),
-        (0x322F, "3", "(土)"),
-        (0x3230, "3", "(日)"),
-        (0x3231, "3", "(株)"),
-        (0x3232, "3", "(有)"),
-        (0x3233, "3", "(社)"),
-        (0x3234, "3", "(名)"),
-        (0x3235, "3", "(特)"),
-        (0x3236, "3", "(財)"),
-        (0x3237, "3", "(祝)"),
-        (0x3238, "3", "(労)"),
-        (0x3239, "3", "(代)"),
-        (0x323A, "3", "(呼)"),
-        (0x323B, "3", "(学)"),
-        (0x323C, "3", "(監)"),
-        (0x323D, "3", "(企)"),
-        (0x323E, "3", "(資)"),
-        (0x323F, "3", "(協)"),
-        (0x3240, "3", "(祭)"),
-        (0x3241, "3", "(休)"),
-        (0x3242, "3", "(自)"),
-    ]
-
-
-def _seg_31():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x3243, "3", "(至)"),
-        (0x3244, "M", "問"),
-        (0x3245, "M", "幼"),
-        (0x3246, "M", "文"),
-        (0x3247, "M", "箏"),
-        (0x3248, "V"),
-        (0x3250, "M", "pte"),
-        (0x3251, "M", "21"),
-        (0x3252, "M", "22"),
-        (0x3253, "M", "23"),
-        (0x3254, "M", "24"),
-        (0x3255, "M", "25"),
-        (0x3256, "M", "26"),
-        (0x3257, "M", "27"),
-        (0x3258, "M", "28"),
-        (0x3259, "M", "29"),
-        (0x325A, "M", "30"),
-        (0x325B, "M", "31"),
-        (0x325C, "M", "32"),
-        (0x325D, "M", "33"),
-        (0x325E, "M", "34"),
-        (0x325F, "M", "35"),
-        (0x3260, "M", "ᄀ"),
-        (0x3261, "M", "ᄂ"),
-        (0x3262, "M", "ᄃ"),
-        (0x3263, "M", "ᄅ"),
-        (0x3264, "M", "ᄆ"),
-        (0x3265, "M", "ᄇ"),
-        (0x3266, "M", "ᄉ"),
-        (0x3267, "M", "ᄋ"),
-        (0x3268, "M", "ᄌ"),
-        (0x3269, "M", "ᄎ"),
-        (0x326A, "M", "ᄏ"),
-        (0x326B, "M", "ᄐ"),
-        (0x326C, "M", "ᄑ"),
-        (0x326D, "M", "ᄒ"),
-        (0x326E, "M", "가"),
-        (0x326F, "M", "나"),
-        (0x3270, "M", "다"),
-        (0x3271, "M", "라"),
-        (0x3272, "M", "마"),
-        (0x3273, "M", "바"),
-        (0x3274, "M", "사"),
-        (0x3275, "M", "아"),
-        (0x3276, "M", "자"),
-        (0x3277, "M", "차"),
-        (0x3278, "M", "카"),
-        (0x3279, "M", "타"),
-        (0x327A, "M", "파"),
-        (0x327B, "M", "하"),
-        (0x327C, "M", "참고"),
-        (0x327D, "M", "주의"),
-        (0x327E, "M", "우"),
-        (0x327F, "V"),
-        (0x3280, "M", "一"),
-        (0x3281, "M", "二"),
-        (0x3282, "M", "三"),
-        (0x3283, "M", "四"),
-        (0x3284, "M", "五"),
-        (0x3285, "M", "六"),
-        (0x3286, "M", "七"),
-        (0x3287, "M", "八"),
-        (0x3288, "M", "九"),
-        (0x3289, "M", "十"),
-        (0x328A, "M", "月"),
-        (0x328B, "M", "火"),
-        (0x328C, "M", "水"),
-        (0x328D, "M", "木"),
-        (0x328E, "M", "金"),
-        (0x328F, "M", "土"),
-        (0x3290, "M", "日"),
-        (0x3291, "M", "株"),
-        (0x3292, "M", "有"),
-        (0x3293, "M", "社"),
-        (0x3294, "M", "名"),
-        (0x3295, "M", "特"),
-        (0x3296, "M", "財"),
-        (0x3297, "M", "祝"),
-        (0x3298, "M", "労"),
-        (0x3299, "M", "秘"),
-        (0x329A, "M", "男"),
-        (0x329B, "M", "女"),
-        (0x329C, "M", "適"),
-        (0x329D, "M", "優"),
-        (0x329E, "M", "印"),
-        (0x329F, "M", "注"),
-        (0x32A0, "M", "項"),
-        (0x32A1, "M", "休"),
-        (0x32A2, "M", "写"),
-        (0x32A3, "M", "正"),
-        (0x32A4, "M", "上"),
-        (0x32A5, "M", "中"),
-        (0x32A6, "M", "下"),
-        (0x32A7, "M", "左"),
-        (0x32A8, "M", "右"),
-        (0x32A9, "M", "医"),
-        (0x32AA, "M", "宗"),
-        (0x32AB, "M", "学"),
-        (0x32AC, "M", "監"),
-        (0x32AD, "M", "企"),
-    ]
-
-
-def _seg_32():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x32AE, "M", "資"),
-        (0x32AF, "M", "協"),
-        (0x32B0, "M", "夜"),
-        (0x32B1, "M", "36"),
-        (0x32B2, "M", "37"),
-        (0x32B3, "M", "38"),
-        (0x32B4, "M", "39"),
-        (0x32B5, "M", "40"),
-        (0x32B6, "M", "41"),
-        (0x32B7, "M", "42"),
-        (0x32B8, "M", "43"),
-        (0x32B9, "M", "44"),
-        (0x32BA, "M", "45"),
-        (0x32BB, "M", "46"),
-        (0x32BC, "M", "47"),
-        (0x32BD, "M", "48"),
-        (0x32BE, "M", "49"),
-        (0x32BF, "M", "50"),
-        (0x32C0, "M", "1月"),
-        (0x32C1, "M", "2月"),
-        (0x32C2, "M", "3月"),
-        (0x32C3, "M", "4月"),
-        (0x32C4, "M", "5月"),
-        (0x32C5, "M", "6月"),
-        (0x32C6, "M", "7月"),
-        (0x32C7, "M", "8月"),
-        (0x32C8, "M", "9月"),
-        (0x32C9, "M", "10月"),
-        (0x32CA, "M", "11月"),
-        (0x32CB, "M", "12月"),
-        (0x32CC, "M", "hg"),
-        (0x32CD, "M", "erg"),
-        (0x32CE, "M", "ev"),
-        (0x32CF, "M", "ltd"),
-        (0x32D0, "M", "ア"),
-        (0x32D1, "M", "イ"),
-        (0x32D2, "M", "ウ"),
-        (0x32D3, "M", "エ"),
-        (0x32D4, "M", "オ"),
-        (0x32D5, "M", "カ"),
-        (0x32D6, "M", "キ"),
-        (0x32D7, "M", "ク"),
-        (0x32D8, "M", "ケ"),
-        (0x32D9, "M", "コ"),
-        (0x32DA, "M", "サ"),
-        (0x32DB, "M", "シ"),
-        (0x32DC, "M", "ス"),
-        (0x32DD, "M", "セ"),
-        (0x32DE, "M", "ソ"),
-        (0x32DF, "M", "タ"),
-        (0x32E0, "M", "チ"),
-        (0x32E1, "M", "ツ"),
-        (0x32E2, "M", "テ"),
-        (0x32E3, "M", "ト"),
-        (0x32E4, "M", "ナ"),
-        (0x32E5, "M", "ニ"),
-        (0x32E6, "M", "ヌ"),
-        (0x32E7, "M", "ネ"),
-        (0x32E8, "M", "ノ"),
-        (0x32E9, "M", "ハ"),
-        (0x32EA, "M", "ヒ"),
-        (0x32EB, "M", "フ"),
-        (0x32EC, "M", "ヘ"),
-        (0x32ED, "M", "ホ"),
-        (0x32EE, "M", "マ"),
-        (0x32EF, "M", "ミ"),
-        (0x32F0, "M", "ム"),
-        (0x32F1, "M", "メ"),
-        (0x32F2, "M", "モ"),
-        (0x32F3, "M", "ヤ"),
-        (0x32F4, "M", "ユ"),
-        (0x32F5, "M", "ヨ"),
-        (0x32F6, "M", "ラ"),
-        (0x32F7, "M", "リ"),
-        (0x32F8, "M", "ル"),
-        (0x32F9, "M", "レ"),
-        (0x32FA, "M", "ロ"),
-        (0x32FB, "M", "ワ"),
-        (0x32FC, "M", "ヰ"),
-        (0x32FD, "M", "ヱ"),
-        (0x32FE, "M", "ヲ"),
-        (0x32FF, "M", "令和"),
-        (0x3300, "M", "アパート"),
-        (0x3301, "M", "アルファ"),
-        (0x3302, "M", "アンペア"),
-        (0x3303, "M", "アール"),
-        (0x3304, "M", "イニング"),
-        (0x3305, "M", "インチ"),
-        (0x3306, "M", "ウォン"),
-        (0x3307, "M", "エスクード"),
-        (0x3308, "M", "エーカー"),
-        (0x3309, "M", "オンス"),
-        (0x330A, "M", "オーム"),
-        (0x330B, "M", "カイリ"),
-        (0x330C, "M", "カラット"),
-        (0x330D, "M", "カロリー"),
-        (0x330E, "M", "ガロン"),
-        (0x330F, "M", "ガンマ"),
-        (0x3310, "M", "ギガ"),
-        (0x3311, "M", "ギニー"),
-    ]
-
-
-def _seg_33():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x3312, "M", "キュリー"),
-        (0x3313, "M", "ギルダー"),
-        (0x3314, "M", "キロ"),
-        (0x3315, "M", "キログラム"),
-        (0x3316, "M", "キロメートル"),
-        (0x3317, "M", "キロワット"),
-        (0x3318, "M", "グラム"),
-        (0x3319, "M", "グラムトン"),
-        (0x331A, "M", "クルゼイロ"),
-        (0x331B, "M", "クローネ"),
-        (0x331C, "M", "ケース"),
-        (0x331D, "M", "コルナ"),
-        (0x331E, "M", "コーポ"),
-        (0x331F, "M", "サイクル"),
-        (0x3320, "M", "サンチーム"),
-        (0x3321, "M", "シリング"),
-        (0x3322, "M", "センチ"),
-        (0x3323, "M", "セント"),
-        (0x3324, "M", "ダース"),
-        (0x3325, "M", "デシ"),
-        (0x3326, "M", "ドル"),
-        (0x3327, "M", "トン"),
-        (0x3328, "M", "ナノ"),
-        (0x3329, "M", "ノット"),
-        (0x332A, "M", "ハイツ"),
-        (0x332B, "M", "パーセント"),
-        (0x332C, "M", "パーツ"),
-        (0x332D, "M", "バーレル"),
-        (0x332E, "M", "ピアストル"),
-        (0x332F, "M", "ピクル"),
-        (0x3330, "M", "ピコ"),
-        (0x3331, "M", "ビル"),
-        (0x3332, "M", "ファラッド"),
-        (0x3333, "M", "フィート"),
-        (0x3334, "M", "ブッシェル"),
-        (0x3335, "M", "フラン"),
-        (0x3336, "M", "ヘクタール"),
-        (0x3337, "M", "ペソ"),
-        (0x3338, "M", "ペニヒ"),
-        (0x3339, "M", "ヘルツ"),
-        (0x333A, "M", "ペンス"),
-        (0x333B, "M", "ページ"),
-        (0x333C, "M", "ベータ"),
-        (0x333D, "M", "ポイント"),
-        (0x333E, "M", "ボルト"),
-        (0x333F, "M", "ホン"),
-        (0x3340, "M", "ポンド"),
-        (0x3341, "M", "ホール"),
-        (0x3342, "M", "ホーン"),
-        (0x3343, "M", "マイクロ"),
-        (0x3344, "M", "マイル"),
-        (0x3345, "M", "マッハ"),
-        (0x3346, "M", "マルク"),
-        (0x3347, "M", "マンション"),
-        (0x3348, "M", "ミクロン"),
-        (0x3349, "M", "ミリ"),
-        (0x334A, "M", "ミリバール"),
-        (0x334B, "M", "メガ"),
-        (0x334C, "M", "メガトン"),
-        (0x334D, "M", "メートル"),
-        (0x334E, "M", "ヤード"),
-        (0x334F, "M", "ヤール"),
-        (0x3350, "M", "ユアン"),
-        (0x3351, "M", "リットル"),
-        (0x3352, "M", "リラ"),
-        (0x3353, "M", "ルピー"),
-        (0x3354, "M", "ルーブル"),
-        (0x3355, "M", "レム"),
-        (0x3356, "M", "レントゲン"),
-        (0x3357, "M", "ワット"),
-        (0x3358, "M", "0点"),
-        (0x3359, "M", "1点"),
-        (0x335A, "M", "2点"),
-        (0x335B, "M", "3点"),
-        (0x335C, "M", "4点"),
-        (0x335D, "M", "5点"),
-        (0x335E, "M", "6点"),
-        (0x335F, "M", "7点"),
-        (0x3360, "M", "8点"),
-        (0x3361, "M", "9点"),
-        (0x3362, "M", "10点"),
-        (0x3363, "M", "11点"),
-        (0x3364, "M", "12点"),
-        (0x3365, "M", "13点"),
-        (0x3366, "M", "14点"),
-        (0x3367, "M", "15点"),
-        (0x3368, "M", "16点"),
-        (0x3369, "M", "17点"),
-        (0x336A, "M", "18点"),
-        (0x336B, "M", "19点"),
-        (0x336C, "M", "20点"),
-        (0x336D, "M", "21点"),
-        (0x336E, "M", "22点"),
-        (0x336F, "M", "23点"),
-        (0x3370, "M", "24点"),
-        (0x3371, "M", "hpa"),
-        (0x3372, "M", "da"),
-        (0x3373, "M", "au"),
-        (0x3374, "M", "bar"),
-        (0x3375, "M", "ov"),
-    ]
-
-
-def _seg_34():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x3376, "M", "pc"),
-        (0x3377, "M", "dm"),
-        (0x3378, "M", "dm2"),
-        (0x3379, "M", "dm3"),
-        (0x337A, "M", "iu"),
-        (0x337B, "M", "平成"),
-        (0x337C, "M", "昭和"),
-        (0x337D, "M", "大正"),
-        (0x337E, "M", "明治"),
-        (0x337F, "M", "株式会社"),
-        (0x3380, "M", "pa"),
-        (0x3381, "M", "na"),
-        (0x3382, "M", "μa"),
-        (0x3383, "M", "ma"),
-        (0x3384, "M", "ka"),
-        (0x3385, "M", "kb"),
-        (0x3386, "M", "mb"),
-        (0x3387, "M", "gb"),
-        (0x3388, "M", "cal"),
-        (0x3389, "M", "kcal"),
-        (0x338A, "M", "pf"),
-        (0x338B, "M", "nf"),
-        (0x338C, "M", "μf"),
-        (0x338D, "M", "μg"),
-        (0x338E, "M", "mg"),
-        (0x338F, "M", "kg"),
-        (0x3390, "M", "hz"),
-        (0x3391, "M", "khz"),
-        (0x3392, "M", "mhz"),
-        (0x3393, "M", "ghz"),
-        (0x3394, "M", "thz"),
-        (0x3395, "M", "μl"),
-        (0x3396, "M", "ml"),
-        (0x3397, "M", "dl"),
-        (0x3398, "M", "kl"),
-        (0x3399, "M", "fm"),
-        (0x339A, "M", "nm"),
-        (0x339B, "M", "μm"),
-        (0x339C, "M", "mm"),
-        (0x339D, "M", "cm"),
-        (0x339E, "M", "km"),
-        (0x339F, "M", "mm2"),
-        (0x33A0, "M", "cm2"),
-        (0x33A1, "M", "m2"),
-        (0x33A2, "M", "km2"),
-        (0x33A3, "M", "mm3"),
-        (0x33A4, "M", "cm3"),
-        (0x33A5, "M", "m3"),
-        (0x33A6, "M", "km3"),
-        (0x33A7, "M", "m∕s"),
-        (0x33A8, "M", "m∕s2"),
-        (0x33A9, "M", "pa"),
-        (0x33AA, "M", "kpa"),
-        (0x33AB, "M", "mpa"),
-        (0x33AC, "M", "gpa"),
-        (0x33AD, "M", "rad"),
-        (0x33AE, "M", "rad∕s"),
-        (0x33AF, "M", "rad∕s2"),
-        (0x33B0, "M", "ps"),
-        (0x33B1, "M", "ns"),
-        (0x33B2, "M", "μs"),
-        (0x33B3, "M", "ms"),
-        (0x33B4, "M", "pv"),
-        (0x33B5, "M", "nv"),
-        (0x33B6, "M", "μv"),
-        (0x33B7, "M", "mv"),
-        (0x33B8, "M", "kv"),
-        (0x33B9, "M", "mv"),
-        (0x33BA, "M", "pw"),
-        (0x33BB, "M", "nw"),
-        (0x33BC, "M", "μw"),
-        (0x33BD, "M", "mw"),
-        (0x33BE, "M", "kw"),
-        (0x33BF, "M", "mw"),
-        (0x33C0, "M", "kω"),
-        (0x33C1, "M", "mω"),
-        (0x33C2, "X"),
-        (0x33C3, "M", "bq"),
-        (0x33C4, "M", "cc"),
-        (0x33C5, "M", "cd"),
-        (0x33C6, "M", "c∕kg"),
-        (0x33C7, "X"),
-        (0x33C8, "M", "db"),
-        (0x33C9, "M", "gy"),
-        (0x33CA, "M", "ha"),
-        (0x33CB, "M", "hp"),
-        (0x33CC, "M", "in"),
-        (0x33CD, "M", "kk"),
-        (0x33CE, "M", "km"),
-        (0x33CF, "M", "kt"),
-        (0x33D0, "M", "lm"),
-        (0x33D1, "M", "ln"),
-        (0x33D2, "M", "log"),
-        (0x33D3, "M", "lx"),
-        (0x33D4, "M", "mb"),
-        (0x33D5, "M", "mil"),
-        (0x33D6, "M", "mol"),
-        (0x33D7, "M", "ph"),
-        (0x33D8, "X"),
-        (0x33D9, "M", "ppm"),
-    ]
-
-
-def _seg_35():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x33DA, "M", "pr"),
-        (0x33DB, "M", "sr"),
-        (0x33DC, "M", "sv"),
-        (0x33DD, "M", "wb"),
-        (0x33DE, "M", "v∕m"),
-        (0x33DF, "M", "a∕m"),
-        (0x33E0, "M", "1日"),
-        (0x33E1, "M", "2日"),
-        (0x33E2, "M", "3日"),
-        (0x33E3, "M", "4日"),
-        (0x33E4, "M", "5日"),
-        (0x33E5, "M", "6日"),
-        (0x33E6, "M", "7日"),
-        (0x33E7, "M", "8日"),
-        (0x33E8, "M", "9日"),
-        (0x33E9, "M", "10日"),
-        (0x33EA, "M", "11日"),
-        (0x33EB, "M", "12日"),
-        (0x33EC, "M", "13日"),
-        (0x33ED, "M", "14日"),
-        (0x33EE, "M", "15日"),
-        (0x33EF, "M", "16日"),
-        (0x33F0, "M", "17日"),
-        (0x33F1, "M", "18日"),
-        (0x33F2, "M", "19日"),
-        (0x33F3, "M", "20日"),
-        (0x33F4, "M", "21日"),
-        (0x33F5, "M", "22日"),
-        (0x33F6, "M", "23日"),
-        (0x33F7, "M", "24日"),
-        (0x33F8, "M", "25日"),
-        (0x33F9, "M", "26日"),
-        (0x33FA, "M", "27日"),
-        (0x33FB, "M", "28日"),
-        (0x33FC, "M", "29日"),
-        (0x33FD, "M", "30日"),
-        (0x33FE, "M", "31日"),
-        (0x33FF, "M", "gal"),
-        (0x3400, "V"),
-        (0x9FFD, "X"),
-        (0xA000, "V"),
-        (0xA48D, "X"),
-        (0xA490, "V"),
-        (0xA4C7, "X"),
-        (0xA4D0, "V"),
-        (0xA62C, "X"),
-        (0xA640, "M", "ꙁ"),
-        (0xA641, "V"),
-        (0xA642, "M", "ꙃ"),
-        (0xA643, "V"),
-        (0xA644, "M", "ꙅ"),
-        (0xA645, "V"),
-        (0xA646, "M", "ꙇ"),
-        (0xA647, "V"),
-        (0xA648, "M", "ꙉ"),
-        (0xA649, "V"),
-        (0xA64A, "M", "ꙋ"),
-        (0xA64B, "V"),
-        (0xA64C, "M", "ꙍ"),
-        (0xA64D, "V"),
-        (0xA64E, "M", "ꙏ"),
-        (0xA64F, "V"),
-        (0xA650, "M", "ꙑ"),
-        (0xA651, "V"),
-        (0xA652, "M", "ꙓ"),
-        (0xA653, "V"),
-        (0xA654, "M", "ꙕ"),
-        (0xA655, "V"),
-        (0xA656, "M", "ꙗ"),
-        (0xA657, "V"),
-        (0xA658, "M", "ꙙ"),
-        (0xA659, "V"),
-        (0xA65A, "M", "ꙛ"),
-        (0xA65B, "V"),
-        (0xA65C, "M", "ꙝ"),
-        (0xA65D, "V"),
-        (0xA65E, "M", "ꙟ"),
-        (0xA65F, "V"),
-        (0xA660, "M", "ꙡ"),
-        (0xA661, "V"),
-        (0xA662, "M", "ꙣ"),
-        (0xA663, "V"),
-        (0xA664, "M", "ꙥ"),
-        (0xA665, "V"),
-        (0xA666, "M", "ꙧ"),
-        (0xA667, "V"),
-        (0xA668, "M", "ꙩ"),
-        (0xA669, "V"),
-        (0xA66A, "M", "ꙫ"),
-        (0xA66B, "V"),
-        (0xA66C, "M", "ꙭ"),
-        (0xA66D, "V"),
-        (0xA680, "M", "ꚁ"),
-        (0xA681, "V"),
-        (0xA682, "M", "ꚃ"),
-        (0xA683, "V"),
-        (0xA684, "M", "ꚅ"),
-        (0xA685, "V"),
-        (0xA686, "M", "ꚇ"),
-        (0xA687, "V"),
-    ]
-
-
-def _seg_36():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xA688, "M", "ꚉ"),
-        (0xA689, "V"),
-        (0xA68A, "M", "ꚋ"),
-        (0xA68B, "V"),
-        (0xA68C, "M", "ꚍ"),
-        (0xA68D, "V"),
-        (0xA68E, "M", "ꚏ"),
-        (0xA68F, "V"),
-        (0xA690, "M", "ꚑ"),
-        (0xA691, "V"),
-        (0xA692, "M", "ꚓ"),
-        (0xA693, "V"),
-        (0xA694, "M", "ꚕ"),
-        (0xA695, "V"),
-        (0xA696, "M", "ꚗ"),
-        (0xA697, "V"),
-        (0xA698, "M", "ꚙ"),
-        (0xA699, "V"),
-        (0xA69A, "M", "ꚛ"),
-        (0xA69B, "V"),
-        (0xA69C, "M", "ъ"),
-        (0xA69D, "M", "ь"),
-        (0xA69E, "V"),
-        (0xA6F8, "X"),
-        (0xA700, "V"),
-        (0xA722, "M", "ꜣ"),
-        (0xA723, "V"),
-        (0xA724, "M", "ꜥ"),
-        (0xA725, "V"),
-        (0xA726, "M", "ꜧ"),
-        (0xA727, "V"),
-        (0xA728, "M", "ꜩ"),
-        (0xA729, "V"),
-        (0xA72A, "M", "ꜫ"),
-        (0xA72B, "V"),
-        (0xA72C, "M", "ꜭ"),
-        (0xA72D, "V"),
-        (0xA72E, "M", "ꜯ"),
-        (0xA72F, "V"),
-        (0xA732, "M", "ꜳ"),
-        (0xA733, "V"),
-        (0xA734, "M", "ꜵ"),
-        (0xA735, "V"),
-        (0xA736, "M", "ꜷ"),
-        (0xA737, "V"),
-        (0xA738, "M", "ꜹ"),
-        (0xA739, "V"),
-        (0xA73A, "M", "ꜻ"),
-        (0xA73B, "V"),
-        (0xA73C, "M", "ꜽ"),
-        (0xA73D, "V"),
-        (0xA73E, "M", "ꜿ"),
-        (0xA73F, "V"),
-        (0xA740, "M", "ꝁ"),
-        (0xA741, "V"),
-        (0xA742, "M", "ꝃ"),
-        (0xA743, "V"),
-        (0xA744, "M", "ꝅ"),
-        (0xA745, "V"),
-        (0xA746, "M", "ꝇ"),
-        (0xA747, "V"),
-        (0xA748, "M", "ꝉ"),
-        (0xA749, "V"),
-        (0xA74A, "M", "ꝋ"),
-        (0xA74B, "V"),
-        (0xA74C, "M", "ꝍ"),
-        (0xA74D, "V"),
-        (0xA74E, "M", "ꝏ"),
-        (0xA74F, "V"),
-        (0xA750, "M", "ꝑ"),
-        (0xA751, "V"),
-        (0xA752, "M", "ꝓ"),
-        (0xA753, "V"),
-        (0xA754, "M", "ꝕ"),
-        (0xA755, "V"),
-        (0xA756, "M", "ꝗ"),
-        (0xA757, "V"),
-        (0xA758, "M", "ꝙ"),
-        (0xA759, "V"),
-        (0xA75A, "M", "ꝛ"),
-        (0xA75B, "V"),
-        (0xA75C, "M", "ꝝ"),
-        (0xA75D, "V"),
-        (0xA75E, "M", "ꝟ"),
-        (0xA75F, "V"),
-        (0xA760, "M", "ꝡ"),
-        (0xA761, "V"),
-        (0xA762, "M", "ꝣ"),
-        (0xA763, "V"),
-        (0xA764, "M", "ꝥ"),
-        (0xA765, "V"),
-        (0xA766, "M", "ꝧ"),
-        (0xA767, "V"),
-        (0xA768, "M", "ꝩ"),
-        (0xA769, "V"),
-        (0xA76A, "M", "ꝫ"),
-        (0xA76B, "V"),
-        (0xA76C, "M", "ꝭ"),
-        (0xA76D, "V"),
-        (0xA76E, "M", "ꝯ"),
-    ]
-
-
-def _seg_37():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xA76F, "V"),
-        (0xA770, "M", "ꝯ"),
-        (0xA771, "V"),
-        (0xA779, "M", "ꝺ"),
-        (0xA77A, "V"),
-        (0xA77B, "M", "ꝼ"),
-        (0xA77C, "V"),
-        (0xA77D, "M", "ᵹ"),
-        (0xA77E, "M", "ꝿ"),
-        (0xA77F, "V"),
-        (0xA780, "M", "ꞁ"),
-        (0xA781, "V"),
-        (0xA782, "M", "ꞃ"),
-        (0xA783, "V"),
-        (0xA784, "M", "ꞅ"),
-        (0xA785, "V"),
-        (0xA786, "M", "ꞇ"),
-        (0xA787, "V"),
-        (0xA78B, "M", "ꞌ"),
-        (0xA78C, "V"),
-        (0xA78D, "M", "ɥ"),
-        (0xA78E, "V"),
-        (0xA790, "M", "ꞑ"),
-        (0xA791, "V"),
-        (0xA792, "M", "ꞓ"),
-        (0xA793, "V"),
-        (0xA796, "M", "ꞗ"),
-        (0xA797, "V"),
-        (0xA798, "M", "ꞙ"),
-        (0xA799, "V"),
-        (0xA79A, "M", "ꞛ"),
-        (0xA79B, "V"),
-        (0xA79C, "M", "ꞝ"),
-        (0xA79D, "V"),
-        (0xA79E, "M", "ꞟ"),
-        (0xA79F, "V"),
-        (0xA7A0, "M", "ꞡ"),
-        (0xA7A1, "V"),
-        (0xA7A2, "M", "ꞣ"),
-        (0xA7A3, "V"),
-        (0xA7A4, "M", "ꞥ"),
-        (0xA7A5, "V"),
-        (0xA7A6, "M", "ꞧ"),
-        (0xA7A7, "V"),
-        (0xA7A8, "M", "ꞩ"),
-        (0xA7A9, "V"),
-        (0xA7AA, "M", "ɦ"),
-        (0xA7AB, "M", "ɜ"),
-        (0xA7AC, "M", "ɡ"),
-        (0xA7AD, "M", "ɬ"),
-        (0xA7AE, "M", "ɪ"),
-        (0xA7AF, "V"),
-        (0xA7B0, "M", "ʞ"),
-        (0xA7B1, "M", "ʇ"),
-        (0xA7B2, "M", "ʝ"),
-        (0xA7B3, "M", "ꭓ"),
-        (0xA7B4, "M", "ꞵ"),
-        (0xA7B5, "V"),
-        (0xA7B6, "M", "ꞷ"),
-        (0xA7B7, "V"),
-        (0xA7B8, "M", "ꞹ"),
-        (0xA7B9, "V"),
-        (0xA7BA, "M", "ꞻ"),
-        (0xA7BB, "V"),
-        (0xA7BC, "M", "ꞽ"),
-        (0xA7BD, "V"),
-        (0xA7BE, "M", "ꞿ"),
-        (0xA7BF, "V"),
-        (0xA7C0, "X"),
-        (0xA7C2, "M", "ꟃ"),
-        (0xA7C3, "V"),
-        (0xA7C4, "M", "ꞔ"),
-        (0xA7C5, "M", "ʂ"),
-        (0xA7C6, "M", "ᶎ"),
-        (0xA7C7, "M", "ꟈ"),
-        (0xA7C8, "V"),
-        (0xA7C9, "M", "ꟊ"),
-        (0xA7CA, "V"),
-        (0xA7CB, "X"),
-        (0xA7F5, "M", "ꟶ"),
-        (0xA7F6, "V"),
-        (0xA7F8, "M", "ħ"),
-        (0xA7F9, "M", "œ"),
-        (0xA7FA, "V"),
-        (0xA82D, "X"),
-        (0xA830, "V"),
-        (0xA83A, "X"),
-        (0xA840, "V"),
-        (0xA878, "X"),
-        (0xA880, "V"),
-        (0xA8C6, "X"),
-        (0xA8CE, "V"),
-        (0xA8DA, "X"),
-        (0xA8E0, "V"),
-        (0xA954, "X"),
-        (0xA95F, "V"),
-        (0xA97D, "X"),
-        (0xA980, "V"),
-        (0xA9CE, "X"),
-        (0xA9CF, "V"),
-    ]
-
-
-def _seg_38():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xA9DA, "X"),
-        (0xA9DE, "V"),
-        (0xA9FF, "X"),
-        (0xAA00, "V"),
-        (0xAA37, "X"),
-        (0xAA40, "V"),
-        (0xAA4E, "X"),
-        (0xAA50, "V"),
-        (0xAA5A, "X"),
-        (0xAA5C, "V"),
-        (0xAAC3, "X"),
-        (0xAADB, "V"),
-        (0xAAF7, "X"),
-        (0xAB01, "V"),
-        (0xAB07, "X"),
-        (0xAB09, "V"),
-        (0xAB0F, "X"),
-        (0xAB11, "V"),
-        (0xAB17, "X"),
-        (0xAB20, "V"),
-        (0xAB27, "X"),
-        (0xAB28, "V"),
-        (0xAB2F, "X"),
-        (0xAB30, "V"),
-        (0xAB5C, "M", "ꜧ"),
-        (0xAB5D, "M", "ꬷ"),
-        (0xAB5E, "M", "ɫ"),
-        (0xAB5F, "M", "ꭒ"),
-        (0xAB60, "V"),
-        (0xAB69, "M", "ʍ"),
-        (0xAB6A, "V"),
-        (0xAB6C, "X"),
-        (0xAB70, "M", "Ꭰ"),
-        (0xAB71, "M", "Ꭱ"),
-        (0xAB72, "M", "Ꭲ"),
-        (0xAB73, "M", "Ꭳ"),
-        (0xAB74, "M", "Ꭴ"),
-        (0xAB75, "M", "Ꭵ"),
-        (0xAB76, "M", "Ꭶ"),
-        (0xAB77, "M", "Ꭷ"),
-        (0xAB78, "M", "Ꭸ"),
-        (0xAB79, "M", "Ꭹ"),
-        (0xAB7A, "M", "Ꭺ"),
-        (0xAB7B, "M", "Ꭻ"),
-        (0xAB7C, "M", "Ꭼ"),
-        (0xAB7D, "M", "Ꭽ"),
-        (0xAB7E, "M", "Ꭾ"),
-        (0xAB7F, "M", "Ꭿ"),
-        (0xAB80, "M", "Ꮀ"),
-        (0xAB81, "M", "Ꮁ"),
-        (0xAB82, "M", "Ꮂ"),
-        (0xAB83, "M", "Ꮃ"),
-        (0xAB84, "M", "Ꮄ"),
-        (0xAB85, "M", "Ꮅ"),
-        (0xAB86, "M", "Ꮆ"),
-        (0xAB87, "M", "Ꮇ"),
-        (0xAB88, "M", "Ꮈ"),
-        (0xAB89, "M", "Ꮉ"),
-        (0xAB8A, "M", "Ꮊ"),
-        (0xAB8B, "M", "Ꮋ"),
-        (0xAB8C, "M", "Ꮌ"),
-        (0xAB8D, "M", "Ꮍ"),
-        (0xAB8E, "M", "Ꮎ"),
-        (0xAB8F, "M", "Ꮏ"),
-        (0xAB90, "M", "Ꮐ"),
-        (0xAB91, "M", "Ꮑ"),
-        (0xAB92, "M", "Ꮒ"),
-        (0xAB93, "M", "Ꮓ"),
-        (0xAB94, "M", "Ꮔ"),
-        (0xAB95, "M", "Ꮕ"),
-        (0xAB96, "M", "Ꮖ"),
-        (0xAB97, "M", "Ꮗ"),
-        (0xAB98, "M", "Ꮘ"),
-        (0xAB99, "M", "Ꮙ"),
-        (0xAB9A, "M", "Ꮚ"),
-        (0xAB9B, "M", "Ꮛ"),
-        (0xAB9C, "M", "Ꮜ"),
-        (0xAB9D, "M", "Ꮝ"),
-        (0xAB9E, "M", "Ꮞ"),
-        (0xAB9F, "M", "Ꮟ"),
-        (0xABA0, "M", "Ꮠ"),
-        (0xABA1, "M", "Ꮡ"),
-        (0xABA2, "M", "Ꮢ"),
-        (0xABA3, "M", "Ꮣ"),
-        (0xABA4, "M", "Ꮤ"),
-        (0xABA5, "M", "Ꮥ"),
-        (0xABA6, "M", "Ꮦ"),
-        (0xABA7, "M", "Ꮧ"),
-        (0xABA8, "M", "Ꮨ"),
-        (0xABA9, "M", "Ꮩ"),
-        (0xABAA, "M", "Ꮪ"),
-        (0xABAB, "M", "Ꮫ"),
-        (0xABAC, "M", "Ꮬ"),
-        (0xABAD, "M", "Ꮭ"),
-        (0xABAE, "M", "Ꮮ"),
-        (0xABAF, "M", "Ꮯ"),
-        (0xABB0, "M", "Ꮰ"),
-        (0xABB1, "M", "Ꮱ"),
-        (0xABB2, "M", "Ꮲ"),
-        (0xABB3, "M", "Ꮳ"),
-    ]
-
-
-def _seg_39():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xABB4, "M", "Ꮴ"),
-        (0xABB5, "M", "Ꮵ"),
-        (0xABB6, "M", "Ꮶ"),
-        (0xABB7, "M", "Ꮷ"),
-        (0xABB8, "M", "Ꮸ"),
-        (0xABB9, "M", "Ꮹ"),
-        (0xABBA, "M", "Ꮺ"),
-        (0xABBB, "M", "Ꮻ"),
-        (0xABBC, "M", "Ꮼ"),
-        (0xABBD, "M", "Ꮽ"),
-        (0xABBE, "M", "Ꮾ"),
-        (0xABBF, "M", "Ꮿ"),
-        (0xABC0, "V"),
-        (0xABEE, "X"),
-        (0xABF0, "V"),
-        (0xABFA, "X"),
-        (0xAC00, "V"),
-        (0xD7A4, "X"),
-        (0xD7B0, "V"),
-        (0xD7C7, "X"),
-        (0xD7CB, "V"),
-        (0xD7FC, "X"),
-        (0xF900, "M", "豈"),
-        (0xF901, "M", "更"),
-        (0xF902, "M", "車"),
-        (0xF903, "M", "賈"),
-        (0xF904, "M", "滑"),
-        (0xF905, "M", "串"),
-        (0xF906, "M", "句"),
-        (0xF907, "M", "龜"),
-        (0xF909, "M", "契"),
-        (0xF90A, "M", "金"),
-        (0xF90B, "M", "喇"),
-        (0xF90C, "M", "奈"),
-        (0xF90D, "M", "懶"),
-        (0xF90E, "M", "癩"),
-        (0xF90F, "M", "羅"),
-        (0xF910, "M", "蘿"),
-        (0xF911, "M", "螺"),
-        (0xF912, "M", "裸"),
-        (0xF913, "M", "邏"),
-        (0xF914, "M", "樂"),
-        (0xF915, "M", "洛"),
-        (0xF916, "M", "烙"),
-        (0xF917, "M", "珞"),
-        (0xF918, "M", "落"),
-        (0xF919, "M", "酪"),
-        (0xF91A, "M", "駱"),
-        (0xF91B, "M", "亂"),
-        (0xF91C, "M", "卵"),
-        (0xF91D, "M", "欄"),
-        (0xF91E, "M", "爛"),
-        (0xF91F, "M", "蘭"),
-        (0xF920, "M", "鸞"),
-        (0xF921, "M", "嵐"),
-        (0xF922, "M", "濫"),
-        (0xF923, "M", "藍"),
-        (0xF924, "M", "襤"),
-        (0xF925, "M", "拉"),
-        (0xF926, "M", "臘"),
-        (0xF927, "M", "蠟"),
-        (0xF928, "M", "廊"),
-        (0xF929, "M", "朗"),
-        (0xF92A, "M", "浪"),
-        (0xF92B, "M", "狼"),
-        (0xF92C, "M", "郎"),
-        (0xF92D, "M", "來"),
-        (0xF92E, "M", "冷"),
-        (0xF92F, "M", "勞"),
-        (0xF930, "M", "擄"),
-        (0xF931, "M", "櫓"),
-        (0xF932, "M", "爐"),
-        (0xF933, "M", "盧"),
-        (0xF934, "M", "老"),
-        (0xF935, "M", "蘆"),
-        (0xF936, "M", "虜"),
-        (0xF937, "M", "路"),
-        (0xF938, "M", "露"),
-        (0xF939, "M", "魯"),
-        (0xF93A, "M", "鷺"),
-        (0xF93B, "M", "碌"),
-        (0xF93C, "M", "祿"),
-        (0xF93D, "M", "綠"),
-        (0xF93E, "M", "菉"),
-        (0xF93F, "M", "錄"),
-        (0xF940, "M", "鹿"),
-        (0xF941, "M", "論"),
-        (0xF942, "M", "壟"),
-        (0xF943, "M", "弄"),
-        (0xF944, "M", "籠"),
-        (0xF945, "M", "聾"),
-        (0xF946, "M", "牢"),
-        (0xF947, "M", "磊"),
-        (0xF948, "M", "賂"),
-        (0xF949, "M", "雷"),
-        (0xF94A, "M", "壘"),
-        (0xF94B, "M", "屢"),
-        (0xF94C, "M", "樓"),
-        (0xF94D, "M", "淚"),
-        (0xF94E, "M", "漏"),
-    ]
-
-
-def _seg_40():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xF94F, "M", "累"),
-        (0xF950, "M", "縷"),
-        (0xF951, "M", "陋"),
-        (0xF952, "M", "勒"),
-        (0xF953, "M", "肋"),
-        (0xF954, "M", "凜"),
-        (0xF955, "M", "凌"),
-        (0xF956, "M", "稜"),
-        (0xF957, "M", "綾"),
-        (0xF958, "M", "菱"),
-        (0xF959, "M", "陵"),
-        (0xF95A, "M", "讀"),
-        (0xF95B, "M", "拏"),
-        (0xF95C, "M", "樂"),
-        (0xF95D, "M", "諾"),
-        (0xF95E, "M", "丹"),
-        (0xF95F, "M", "寧"),
-        (0xF960, "M", "怒"),
-        (0xF961, "M", "率"),
-        (0xF962, "M", "異"),
-        (0xF963, "M", "北"),
-        (0xF964, "M", "磻"),
-        (0xF965, "M", "便"),
-        (0xF966, "M", "復"),
-        (0xF967, "M", "不"),
-        (0xF968, "M", "泌"),
-        (0xF969, "M", "數"),
-        (0xF96A, "M", "索"),
-        (0xF96B, "M", "參"),
-        (0xF96C, "M", "塞"),
-        (0xF96D, "M", "省"),
-        (0xF96E, "M", "葉"),
-        (0xF96F, "M", "說"),
-        (0xF970, "M", "殺"),
-        (0xF971, "M", "辰"),
-        (0xF972, "M", "沈"),
-        (0xF973, "M", "拾"),
-        (0xF974, "M", "若"),
-        (0xF975, "M", "掠"),
-        (0xF976, "M", "略"),
-        (0xF977, "M", "亮"),
-        (0xF978, "M", "兩"),
-        (0xF979, "M", "凉"),
-        (0xF97A, "M", "梁"),
-        (0xF97B, "M", "糧"),
-        (0xF97C, "M", "良"),
-        (0xF97D, "M", "諒"),
-        (0xF97E, "M", "量"),
-        (0xF97F, "M", "勵"),
-        (0xF980, "M", "呂"),
-        (0xF981, "M", "女"),
-        (0xF982, "M", "廬"),
-        (0xF983, "M", "旅"),
-        (0xF984, "M", "濾"),
-        (0xF985, "M", "礪"),
-        (0xF986, "M", "閭"),
-        (0xF987, "M", "驪"),
-        (0xF988, "M", "麗"),
-        (0xF989, "M", "黎"),
-        (0xF98A, "M", "力"),
-        (0xF98B, "M", "曆"),
-        (0xF98C, "M", "歷"),
-        (0xF98D, "M", "轢"),
-        (0xF98E, "M", "年"),
-        (0xF98F, "M", "憐"),
-        (0xF990, "M", "戀"),
-        (0xF991, "M", "撚"),
-        (0xF992, "M", "漣"),
-        (0xF993, "M", "煉"),
-        (0xF994, "M", "璉"),
-        (0xF995, "M", "秊"),
-        (0xF996, "M", "練"),
-        (0xF997, "M", "聯"),
-        (0xF998, "M", "輦"),
-        (0xF999, "M", "蓮"),
-        (0xF99A, "M", "連"),
-        (0xF99B, "M", "鍊"),
-        (0xF99C, "M", "列"),
-        (0xF99D, "M", "劣"),
-        (0xF99E, "M", "咽"),
-        (0xF99F, "M", "烈"),
-        (0xF9A0, "M", "裂"),
-        (0xF9A1, "M", "說"),
-        (0xF9A2, "M", "廉"),
-        (0xF9A3, "M", "念"),
-        (0xF9A4, "M", "捻"),
-        (0xF9A5, "M", "殮"),
-        (0xF9A6, "M", "簾"),
-        (0xF9A7, "M", "獵"),
-        (0xF9A8, "M", "令"),
-        (0xF9A9, "M", "囹"),
-        (0xF9AA, "M", "寧"),
-        (0xF9AB, "M", "嶺"),
-        (0xF9AC, "M", "怜"),
-        (0xF9AD, "M", "玲"),
-        (0xF9AE, "M", "瑩"),
-        (0xF9AF, "M", "羚"),
-        (0xF9B0, "M", "聆"),
-        (0xF9B1, "M", "鈴"),
-        (0xF9B2, "M", "零"),
-    ]
-
-
-def _seg_41():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xF9B3, "M", "靈"),
-        (0xF9B4, "M", "領"),
-        (0xF9B5, "M", "例"),
-        (0xF9B6, "M", "禮"),
-        (0xF9B7, "M", "醴"),
-        (0xF9B8, "M", "隸"),
-        (0xF9B9, "M", "惡"),
-        (0xF9BA, "M", "了"),
-        (0xF9BB, "M", "僚"),
-        (0xF9BC, "M", "寮"),
-        (0xF9BD, "M", "尿"),
-        (0xF9BE, "M", "料"),
-        (0xF9BF, "M", "樂"),
-        (0xF9C0, "M", "燎"),
-        (0xF9C1, "M", "療"),
-        (0xF9C2, "M", "蓼"),
-        (0xF9C3, "M", "遼"),
-        (0xF9C4, "M", "龍"),
-        (0xF9C5, "M", "暈"),
-        (0xF9C6, "M", "阮"),
-        (0xF9C7, "M", "劉"),
-        (0xF9C8, "M", "杻"),
-        (0xF9C9, "M", "柳"),
-        (0xF9CA, "M", "流"),
-        (0xF9CB, "M", "溜"),
-        (0xF9CC, "M", "琉"),
-        (0xF9CD, "M", "留"),
-        (0xF9CE, "M", "硫"),
-        (0xF9CF, "M", "紐"),
-        (0xF9D0, "M", "類"),
-        (0xF9D1, "M", "六"),
-        (0xF9D2, "M", "戮"),
-        (0xF9D3, "M", "陸"),
-        (0xF9D4, "M", "倫"),
-        (0xF9D5, "M", "崙"),
-        (0xF9D6, "M", "淪"),
-        (0xF9D7, "M", "輪"),
-        (0xF9D8, "M", "律"),
-        (0xF9D9, "M", "慄"),
-        (0xF9DA, "M", "栗"),
-        (0xF9DB, "M", "率"),
-        (0xF9DC, "M", "隆"),
-        (0xF9DD, "M", "利"),
-        (0xF9DE, "M", "吏"),
-        (0xF9DF, "M", "履"),
-        (0xF9E0, "M", "易"),
-        (0xF9E1, "M", "李"),
-        (0xF9E2, "M", "梨"),
-        (0xF9E3, "M", "泥"),
-        (0xF9E4, "M", "理"),
-        (0xF9E5, "M", "痢"),
-        (0xF9E6, "M", "罹"),
-        (0xF9E7, "M", "裏"),
-        (0xF9E8, "M", "裡"),
-        (0xF9E9, "M", "里"),
-        (0xF9EA, "M", "離"),
-        (0xF9EB, "M", "匿"),
-        (0xF9EC, "M", "溺"),
-        (0xF9ED, "M", "吝"),
-        (0xF9EE, "M", "燐"),
-        (0xF9EF, "M", "璘"),
-        (0xF9F0, "M", "藺"),
-        (0xF9F1, "M", "隣"),
-        (0xF9F2, "M", "鱗"),
-        (0xF9F3, "M", "麟"),
-        (0xF9F4, "M", "林"),
-        (0xF9F5, "M", "淋"),
-        (0xF9F6, "M", "臨"),
-        (0xF9F7, "M", "立"),
-        (0xF9F8, "M", "笠"),
-        (0xF9F9, "M", "粒"),
-        (0xF9FA, "M", "狀"),
-        (0xF9FB, "M", "炙"),
-        (0xF9FC, "M", "識"),
-        (0xF9FD, "M", "什"),
-        (0xF9FE, "M", "茶"),
-        (0xF9FF, "M", "刺"),
-        (0xFA00, "M", "切"),
-        (0xFA01, "M", "度"),
-        (0xFA02, "M", "拓"),
-        (0xFA03, "M", "糖"),
-        (0xFA04, "M", "宅"),
-        (0xFA05, "M", "洞"),
-        (0xFA06, "M", "暴"),
-        (0xFA07, "M", "輻"),
-        (0xFA08, "M", "行"),
-        (0xFA09, "M", "降"),
-        (0xFA0A, "M", "見"),
-        (0xFA0B, "M", "廓"),
-        (0xFA0C, "M", "兀"),
-        (0xFA0D, "M", "嗀"),
-        (0xFA0E, "V"),
-        (0xFA10, "M", "塚"),
-        (0xFA11, "V"),
-        (0xFA12, "M", "晴"),
-        (0xFA13, "V"),
-        (0xFA15, "M", "凞"),
-        (0xFA16, "M", "猪"),
-        (0xFA17, "M", "益"),
-        (0xFA18, "M", "礼"),
-    ]
-
-
-def _seg_42():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFA19, "M", "神"),
-        (0xFA1A, "M", "祥"),
-        (0xFA1B, "M", "福"),
-        (0xFA1C, "M", "靖"),
-        (0xFA1D, "M", "精"),
-        (0xFA1E, "M", "羽"),
-        (0xFA1F, "V"),
-        (0xFA20, "M", "蘒"),
-        (0xFA21, "V"),
-        (0xFA22, "M", "諸"),
-        (0xFA23, "V"),
-        (0xFA25, "M", "逸"),
-        (0xFA26, "M", "都"),
-        (0xFA27, "V"),
-        (0xFA2A, "M", "飯"),
-        (0xFA2B, "M", "飼"),
-        (0xFA2C, "M", "館"),
-        (0xFA2D, "M", "鶴"),
-        (0xFA2E, "M", "郞"),
-        (0xFA2F, "M", "隷"),
-        (0xFA30, "M", "侮"),
-        (0xFA31, "M", "僧"),
-        (0xFA32, "M", "免"),
-        (0xFA33, "M", "勉"),
-        (0xFA34, "M", "勤"),
-        (0xFA35, "M", "卑"),
-        (0xFA36, "M", "喝"),
-        (0xFA37, "M", "嘆"),
-        (0xFA38, "M", "器"),
-        (0xFA39, "M", "塀"),
-        (0xFA3A, "M", "墨"),
-        (0xFA3B, "M", "層"),
-        (0xFA3C, "M", "屮"),
-        (0xFA3D, "M", "悔"),
-        (0xFA3E, "M", "慨"),
-        (0xFA3F, "M", "憎"),
-        (0xFA40, "M", "懲"),
-        (0xFA41, "M", "敏"),
-        (0xFA42, "M", "既"),
-        (0xFA43, "M", "暑"),
-        (0xFA44, "M", "梅"),
-        (0xFA45, "M", "海"),
-        (0xFA46, "M", "渚"),
-        (0xFA47, "M", "漢"),
-        (0xFA48, "M", "煮"),
-        (0xFA49, "M", "爫"),
-        (0xFA4A, "M", "琢"),
-        (0xFA4B, "M", "碑"),
-        (0xFA4C, "M", "社"),
-        (0xFA4D, "M", "祉"),
-        (0xFA4E, "M", "祈"),
-        (0xFA4F, "M", "祐"),
-        (0xFA50, "M", "祖"),
-        (0xFA51, "M", "祝"),
-        (0xFA52, "M", "禍"),
-        (0xFA53, "M", "禎"),
-        (0xFA54, "M", "穀"),
-        (0xFA55, "M", "突"),
-        (0xFA56, "M", "節"),
-        (0xFA57, "M", "練"),
-        (0xFA58, "M", "縉"),
-        (0xFA59, "M", "繁"),
-        (0xFA5A, "M", "署"),
-        (0xFA5B, "M", "者"),
-        (0xFA5C, "M", "臭"),
-        (0xFA5D, "M", "艹"),
-        (0xFA5F, "M", "著"),
-        (0xFA60, "M", "褐"),
-        (0xFA61, "M", "視"),
-        (0xFA62, "M", "謁"),
-        (0xFA63, "M", "謹"),
-        (0xFA64, "M", "賓"),
-        (0xFA65, "M", "贈"),
-        (0xFA66, "M", "辶"),
-        (0xFA67, "M", "逸"),
-        (0xFA68, "M", "難"),
-        (0xFA69, "M", "響"),
-        (0xFA6A, "M", "頻"),
-        (0xFA6B, "M", "恵"),
-        (0xFA6C, "M", "𤋮"),
-        (0xFA6D, "M", "舘"),
-        (0xFA6E, "X"),
-        (0xFA70, "M", "並"),
-        (0xFA71, "M", "况"),
-        (0xFA72, "M", "全"),
-        (0xFA73, "M", "侀"),
-        (0xFA74, "M", "充"),
-        (0xFA75, "M", "冀"),
-        (0xFA76, "M", "勇"),
-        (0xFA77, "M", "勺"),
-        (0xFA78, "M", "喝"),
-        (0xFA79, "M", "啕"),
-        (0xFA7A, "M", "喙"),
-        (0xFA7B, "M", "嗢"),
-        (0xFA7C, "M", "塚"),
-        (0xFA7D, "M", "墳"),
-        (0xFA7E, "M", "奄"),
-        (0xFA7F, "M", "奔"),
-        (0xFA80, "M", "婢"),
-        (0xFA81, "M", "嬨"),
-    ]
-
-
-def _seg_43():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFA82, "M", "廒"),
-        (0xFA83, "M", "廙"),
-        (0xFA84, "M", "彩"),
-        (0xFA85, "M", "徭"),
-        (0xFA86, "M", "惘"),
-        (0xFA87, "M", "慎"),
-        (0xFA88, "M", "愈"),
-        (0xFA89, "M", "憎"),
-        (0xFA8A, "M", "慠"),
-        (0xFA8B, "M", "懲"),
-        (0xFA8C, "M", "戴"),
-        (0xFA8D, "M", "揄"),
-        (0xFA8E, "M", "搜"),
-        (0xFA8F, "M", "摒"),
-        (0xFA90, "M", "敖"),
-        (0xFA91, "M", "晴"),
-        (0xFA92, "M", "朗"),
-        (0xFA93, "M", "望"),
-        (0xFA94, "M", "杖"),
-        (0xFA95, "M", "歹"),
-        (0xFA96, "M", "殺"),
-        (0xFA97, "M", "流"),
-        (0xFA98, "M", "滛"),
-        (0xFA99, "M", "滋"),
-        (0xFA9A, "M", "漢"),
-        (0xFA9B, "M", "瀞"),
-        (0xFA9C, "M", "煮"),
-        (0xFA9D, "M", "瞧"),
-        (0xFA9E, "M", "爵"),
-        (0xFA9F, "M", "犯"),
-        (0xFAA0, "M", "猪"),
-        (0xFAA1, "M", "瑱"),
-        (0xFAA2, "M", "甆"),
-        (0xFAA3, "M", "画"),
-        (0xFAA4, "M", "瘝"),
-        (0xFAA5, "M", "瘟"),
-        (0xFAA6, "M", "益"),
-        (0xFAA7, "M", "盛"),
-        (0xFAA8, "M", "直"),
-        (0xFAA9, "M", "睊"),
-        (0xFAAA, "M", "着"),
-        (0xFAAB, "M", "磌"),
-        (0xFAAC, "M", "窱"),
-        (0xFAAD, "M", "節"),
-        (0xFAAE, "M", "类"),
-        (0xFAAF, "M", "絛"),
-        (0xFAB0, "M", "練"),
-        (0xFAB1, "M", "缾"),
-        (0xFAB2, "M", "者"),
-        (0xFAB3, "M", "荒"),
-        (0xFAB4, "M", "華"),
-        (0xFAB5, "M", "蝹"),
-        (0xFAB6, "M", "襁"),
-        (0xFAB7, "M", "覆"),
-        (0xFAB8, "M", "視"),
-        (0xFAB9, "M", "調"),
-        (0xFABA, "M", "諸"),
-        (0xFABB, "M", "請"),
-        (0xFABC, "M", "謁"),
-        (0xFABD, "M", "諾"),
-        (0xFABE, "M", "諭"),
-        (0xFABF, "M", "謹"),
-        (0xFAC0, "M", "變"),
-        (0xFAC1, "M", "贈"),
-        (0xFAC2, "M", "輸"),
-        (0xFAC3, "M", "遲"),
-        (0xFAC4, "M", "醙"),
-        (0xFAC5, "M", "鉶"),
-        (0xFAC6, "M", "陼"),
-        (0xFAC7, "M", "難"),
-        (0xFAC8, "M", "靖"),
-        (0xFAC9, "M", "韛"),
-        (0xFACA, "M", "響"),
-        (0xFACB, "M", "頋"),
-        (0xFACC, "M", "頻"),
-        (0xFACD, "M", "鬒"),
-        (0xFACE, "M", "龜"),
-        (0xFACF, "M", "𢡊"),
-        (0xFAD0, "M", "𢡄"),
-        (0xFAD1, "M", "𣏕"),
-        (0xFAD2, "M", "㮝"),
-        (0xFAD3, "M", "䀘"),
-        (0xFAD4, "M", "䀹"),
-        (0xFAD5, "M", "𥉉"),
-        (0xFAD6, "M", "𥳐"),
-        (0xFAD7, "M", "𧻓"),
-        (0xFAD8, "M", "齃"),
-        (0xFAD9, "M", "龎"),
-        (0xFADA, "X"),
-        (0xFB00, "M", "ff"),
-        (0xFB01, "M", "fi"),
-        (0xFB02, "M", "fl"),
-        (0xFB03, "M", "ffi"),
-        (0xFB04, "M", "ffl"),
-        (0xFB05, "M", "st"),
-        (0xFB07, "X"),
-        (0xFB13, "M", "մն"),
-        (0xFB14, "M", "մե"),
-        (0xFB15, "M", "մի"),
-        (0xFB16, "M", "վն"),
-    ]
-
-
-def _seg_44():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFB17, "M", "մխ"),
-        (0xFB18, "X"),
-        (0xFB1D, "M", "יִ"),
-        (0xFB1E, "V"),
-        (0xFB1F, "M", "ײַ"),
-        (0xFB20, "M", "ע"),
-        (0xFB21, "M", "א"),
-        (0xFB22, "M", "ד"),
-        (0xFB23, "M", "ה"),
-        (0xFB24, "M", "כ"),
-        (0xFB25, "M", "ל"),
-        (0xFB26, "M", "ם"),
-        (0xFB27, "M", "ר"),
-        (0xFB28, "M", "ת"),
-        (0xFB29, "3", "+"),
-        (0xFB2A, "M", "שׁ"),
-        (0xFB2B, "M", "שׂ"),
-        (0xFB2C, "M", "שּׁ"),
-        (0xFB2D, "M", "שּׂ"),
-        (0xFB2E, "M", "אַ"),
-        (0xFB2F, "M", "אָ"),
-        (0xFB30, "M", "אּ"),
-        (0xFB31, "M", "בּ"),
-        (0xFB32, "M", "גּ"),
-        (0xFB33, "M", "דּ"),
-        (0xFB34, "M", "הּ"),
-        (0xFB35, "M", "וּ"),
-        (0xFB36, "M", "זּ"),
-        (0xFB37, "X"),
-        (0xFB38, "M", "טּ"),
-        (0xFB39, "M", "יּ"),
-        (0xFB3A, "M", "ךּ"),
-        (0xFB3B, "M", "כּ"),
-        (0xFB3C, "M", "לּ"),
-        (0xFB3D, "X"),
-        (0xFB3E, "M", "מּ"),
-        (0xFB3F, "X"),
-        (0xFB40, "M", "נּ"),
-        (0xFB41, "M", "סּ"),
-        (0xFB42, "X"),
-        (0xFB43, "M", "ףּ"),
-        (0xFB44, "M", "פּ"),
-        (0xFB45, "X"),
-        (0xFB46, "M", "צּ"),
-        (0xFB47, "M", "קּ"),
-        (0xFB48, "M", "רּ"),
-        (0xFB49, "M", "שּ"),
-        (0xFB4A, "M", "תּ"),
-        (0xFB4B, "M", "וֹ"),
-        (0xFB4C, "M", "בֿ"),
-        (0xFB4D, "M", "כֿ"),
-        (0xFB4E, "M", "פֿ"),
-        (0xFB4F, "M", "אל"),
-        (0xFB50, "M", "ٱ"),
-        (0xFB52, "M", "ٻ"),
-        (0xFB56, "M", "پ"),
-        (0xFB5A, "M", "ڀ"),
-        (0xFB5E, "M", "ٺ"),
-        (0xFB62, "M", "ٿ"),
-        (0xFB66, "M", "ٹ"),
-        (0xFB6A, "M", "ڤ"),
-        (0xFB6E, "M", "ڦ"),
-        (0xFB72, "M", "ڄ"),
-        (0xFB76, "M", "ڃ"),
-        (0xFB7A, "M", "چ"),
-        (0xFB7E, "M", "ڇ"),
-        (0xFB82, "M", "ڍ"),
-        (0xFB84, "M", "ڌ"),
-        (0xFB86, "M", "ڎ"),
-        (0xFB88, "M", "ڈ"),
-        (0xFB8A, "M", "ژ"),
-        (0xFB8C, "M", "ڑ"),
-        (0xFB8E, "M", "ک"),
-        (0xFB92, "M", "گ"),
-        (0xFB96, "M", "ڳ"),
-        (0xFB9A, "M", "ڱ"),
-        (0xFB9E, "M", "ں"),
-        (0xFBA0, "M", "ڻ"),
-        (0xFBA4, "M", "ۀ"),
-        (0xFBA6, "M", "ہ"),
-        (0xFBAA, "M", "ھ"),
-        (0xFBAE, "M", "ے"),
-        (0xFBB0, "M", "ۓ"),
-        (0xFBB2, "V"),
-        (0xFBC2, "X"),
-        (0xFBD3, "M", "ڭ"),
-        (0xFBD7, "M", "ۇ"),
-        (0xFBD9, "M", "ۆ"),
-        (0xFBDB, "M", "ۈ"),
-        (0xFBDD, "M", "ۇٴ"),
-        (0xFBDE, "M", "ۋ"),
-        (0xFBE0, "M", "ۅ"),
-        (0xFBE2, "M", "ۉ"),
-        (0xFBE4, "M", "ې"),
-        (0xFBE8, "M", "ى"),
-        (0xFBEA, "M", "ئا"),
-        (0xFBEC, "M", "ئە"),
-        (0xFBEE, "M", "ئو"),
-        (0xFBF0, "M", "ئۇ"),
-        (0xFBF2, "M", "ئۆ"),
-    ]
-
-
-def _seg_45():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFBF4, "M", "ئۈ"),
-        (0xFBF6, "M", "ئې"),
-        (0xFBF9, "M", "ئى"),
-        (0xFBFC, "M", "ی"),
-        (0xFC00, "M", "ئج"),
-        (0xFC01, "M", "ئح"),
-        (0xFC02, "M", "ئم"),
-        (0xFC03, "M", "ئى"),
-        (0xFC04, "M", "ئي"),
-        (0xFC05, "M", "بج"),
-        (0xFC06, "M", "بح"),
-        (0xFC07, "M", "بخ"),
-        (0xFC08, "M", "بم"),
-        (0xFC09, "M", "بى"),
-        (0xFC0A, "M", "بي"),
-        (0xFC0B, "M", "تج"),
-        (0xFC0C, "M", "تح"),
-        (0xFC0D, "M", "تخ"),
-        (0xFC0E, "M", "تم"),
-        (0xFC0F, "M", "تى"),
-        (0xFC10, "M", "تي"),
-        (0xFC11, "M", "ثج"),
-        (0xFC12, "M", "ثم"),
-        (0xFC13, "M", "ثى"),
-        (0xFC14, "M", "ثي"),
-        (0xFC15, "M", "جح"),
-        (0xFC16, "M", "جم"),
-        (0xFC17, "M", "حج"),
-        (0xFC18, "M", "حم"),
-        (0xFC19, "M", "خج"),
-        (0xFC1A, "M", "خح"),
-        (0xFC1B, "M", "خم"),
-        (0xFC1C, "M", "سج"),
-        (0xFC1D, "M", "سح"),
-        (0xFC1E, "M", "سخ"),
-        (0xFC1F, "M", "سم"),
-        (0xFC20, "M", "صح"),
-        (0xFC21, "M", "صم"),
-        (0xFC22, "M", "ضج"),
-        (0xFC23, "M", "ضح"),
-        (0xFC24, "M", "ضخ"),
-        (0xFC25, "M", "ضم"),
-        (0xFC26, "M", "طح"),
-        (0xFC27, "M", "طم"),
-        (0xFC28, "M", "ظم"),
-        (0xFC29, "M", "عج"),
-        (0xFC2A, "M", "عم"),
-        (0xFC2B, "M", "غج"),
-        (0xFC2C, "M", "غم"),
-        (0xFC2D, "M", "فج"),
-        (0xFC2E, "M", "فح"),
-        (0xFC2F, "M", "فخ"),
-        (0xFC30, "M", "فم"),
-        (0xFC31, "M", "فى"),
-        (0xFC32, "M", "في"),
-        (0xFC33, "M", "قح"),
-        (0xFC34, "M", "قم"),
-        (0xFC35, "M", "قى"),
-        (0xFC36, "M", "قي"),
-        (0xFC37, "M", "كا"),
-        (0xFC38, "M", "كج"),
-        (0xFC39, "M", "كح"),
-        (0xFC3A, "M", "كخ"),
-        (0xFC3B, "M", "كل"),
-        (0xFC3C, "M", "كم"),
-        (0xFC3D, "M", "كى"),
-        (0xFC3E, "M", "كي"),
-        (0xFC3F, "M", "لج"),
-        (0xFC40, "M", "لح"),
-        (0xFC41, "M", "لخ"),
-        (0xFC42, "M", "لم"),
-        (0xFC43, "M", "لى"),
-        (0xFC44, "M", "لي"),
-        (0xFC45, "M", "مج"),
-        (0xFC46, "M", "مح"),
-        (0xFC47, "M", "مخ"),
-        (0xFC48, "M", "مم"),
-        (0xFC49, "M", "مى"),
-        (0xFC4A, "M", "مي"),
-        (0xFC4B, "M", "نج"),
-        (0xFC4C, "M", "نح"),
-        (0xFC4D, "M", "نخ"),
-        (0xFC4E, "M", "نم"),
-        (0xFC4F, "M", "نى"),
-        (0xFC50, "M", "ني"),
-        (0xFC51, "M", "هج"),
-        (0xFC52, "M", "هم"),
-        (0xFC53, "M", "هى"),
-        (0xFC54, "M", "هي"),
-        (0xFC55, "M", "يج"),
-        (0xFC56, "M", "يح"),
-        (0xFC57, "M", "يخ"),
-        (0xFC58, "M", "يم"),
-        (0xFC59, "M", "يى"),
-        (0xFC5A, "M", "يي"),
-        (0xFC5B, "M", "ذٰ"),
-        (0xFC5C, "M", "رٰ"),
-        (0xFC5D, "M", "ىٰ"),
-        (0xFC5E, "3", " ٌّ"),
-        (0xFC5F, "3", " ٍّ"),
-    ]
-
-
-def _seg_46():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFC60, "3", " َّ"),
-        (0xFC61, "3", " ُّ"),
-        (0xFC62, "3", " ِّ"),
-        (0xFC63, "3", " ّٰ"),
-        (0xFC64, "M", "ئر"),
-        (0xFC65, "M", "ئز"),
-        (0xFC66, "M", "ئم"),
-        (0xFC67, "M", "ئن"),
-        (0xFC68, "M", "ئى"),
-        (0xFC69, "M", "ئي"),
-        (0xFC6A, "M", "بر"),
-        (0xFC6B, "M", "بز"),
-        (0xFC6C, "M", "بم"),
-        (0xFC6D, "M", "بن"),
-        (0xFC6E, "M", "بى"),
-        (0xFC6F, "M", "بي"),
-        (0xFC70, "M", "تر"),
-        (0xFC71, "M", "تز"),
-        (0xFC72, "M", "تم"),
-        (0xFC73, "M", "تن"),
-        (0xFC74, "M", "تى"),
-        (0xFC75, "M", "تي"),
-        (0xFC76, "M", "ثر"),
-        (0xFC77, "M", "ثز"),
-        (0xFC78, "M", "ثم"),
-        (0xFC79, "M", "ثن"),
-        (0xFC7A, "M", "ثى"),
-        (0xFC7B, "M", "ثي"),
-        (0xFC7C, "M", "فى"),
-        (0xFC7D, "M", "في"),
-        (0xFC7E, "M", "قى"),
-        (0xFC7F, "M", "قي"),
-        (0xFC80, "M", "كا"),
-        (0xFC81, "M", "كل"),
-        (0xFC82, "M", "كم"),
-        (0xFC83, "M", "كى"),
-        (0xFC84, "M", "كي"),
-        (0xFC85, "M", "لم"),
-        (0xFC86, "M", "لى"),
-        (0xFC87, "M", "لي"),
-        (0xFC88, "M", "ما"),
-        (0xFC89, "M", "مم"),
-        (0xFC8A, "M", "نر"),
-        (0xFC8B, "M", "نز"),
-        (0xFC8C, "M", "نم"),
-        (0xFC8D, "M", "نن"),
-        (0xFC8E, "M", "نى"),
-        (0xFC8F, "M", "ني"),
-        (0xFC90, "M", "ىٰ"),
-        (0xFC91, "M", "ير"),
-        (0xFC92, "M", "يز"),
-        (0xFC93, "M", "يم"),
-        (0xFC94, "M", "ين"),
-        (0xFC95, "M", "يى"),
-        (0xFC96, "M", "يي"),
-        (0xFC97, "M", "ئج"),
-        (0xFC98, "M", "ئح"),
-        (0xFC99, "M", "ئخ"),
-        (0xFC9A, "M", "ئم"),
-        (0xFC9B, "M", "ئه"),
-        (0xFC9C, "M", "بج"),
-        (0xFC9D, "M", "بح"),
-        (0xFC9E, "M", "بخ"),
-        (0xFC9F, "M", "بم"),
-        (0xFCA0, "M", "به"),
-        (0xFCA1, "M", "تج"),
-        (0xFCA2, "M", "تح"),
-        (0xFCA3, "M", "تخ"),
-        (0xFCA4, "M", "تم"),
-        (0xFCA5, "M", "ته"),
-        (0xFCA6, "M", "ثم"),
-        (0xFCA7, "M", "جح"),
-        (0xFCA8, "M", "جم"),
-        (0xFCA9, "M", "حج"),
-        (0xFCAA, "M", "حم"),
-        (0xFCAB, "M", "خج"),
-        (0xFCAC, "M", "خم"),
-        (0xFCAD, "M", "سج"),
-        (0xFCAE, "M", "سح"),
-        (0xFCAF, "M", "سخ"),
-        (0xFCB0, "M", "سم"),
-        (0xFCB1, "M", "صح"),
-        (0xFCB2, "M", "صخ"),
-        (0xFCB3, "M", "صم"),
-        (0xFCB4, "M", "ضج"),
-        (0xFCB5, "M", "ضح"),
-        (0xFCB6, "M", "ضخ"),
-        (0xFCB7, "M", "ضم"),
-        (0xFCB8, "M", "طح"),
-        (0xFCB9, "M", "ظم"),
-        (0xFCBA, "M", "عج"),
-        (0xFCBB, "M", "عم"),
-        (0xFCBC, "M", "غج"),
-        (0xFCBD, "M", "غم"),
-        (0xFCBE, "M", "فج"),
-        (0xFCBF, "M", "فح"),
-        (0xFCC0, "M", "فخ"),
-        (0xFCC1, "M", "فم"),
-        (0xFCC2, "M", "قح"),
-        (0xFCC3, "M", "قم"),
-    ]
-
-
-def _seg_47():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFCC4, "M", "كج"),
-        (0xFCC5, "M", "كح"),
-        (0xFCC6, "M", "كخ"),
-        (0xFCC7, "M", "كل"),
-        (0xFCC8, "M", "كم"),
-        (0xFCC9, "M", "لج"),
-        (0xFCCA, "M", "لح"),
-        (0xFCCB, "M", "لخ"),
-        (0xFCCC, "M", "لم"),
-        (0xFCCD, "M", "له"),
-        (0xFCCE, "M", "مج"),
-        (0xFCCF, "M", "مح"),
-        (0xFCD0, "M", "مخ"),
-        (0xFCD1, "M", "مم"),
-        (0xFCD2, "M", "نج"),
-        (0xFCD3, "M", "نح"),
-        (0xFCD4, "M", "نخ"),
-        (0xFCD5, "M", "نم"),
-        (0xFCD6, "M", "نه"),
-        (0xFCD7, "M", "هج"),
-        (0xFCD8, "M", "هم"),
-        (0xFCD9, "M", "هٰ"),
-        (0xFCDA, "M", "يج"),
-        (0xFCDB, "M", "يح"),
-        (0xFCDC, "M", "يخ"),
-        (0xFCDD, "M", "يم"),
-        (0xFCDE, "M", "يه"),
-        (0xFCDF, "M", "ئم"),
-        (0xFCE0, "M", "ئه"),
-        (0xFCE1, "M", "بم"),
-        (0xFCE2, "M", "به"),
-        (0xFCE3, "M", "تم"),
-        (0xFCE4, "M", "ته"),
-        (0xFCE5, "M", "ثم"),
-        (0xFCE6, "M", "ثه"),
-        (0xFCE7, "M", "سم"),
-        (0xFCE8, "M", "سه"),
-        (0xFCE9, "M", "شم"),
-        (0xFCEA, "M", "شه"),
-        (0xFCEB, "M", "كل"),
-        (0xFCEC, "M", "كم"),
-        (0xFCED, "M", "لم"),
-        (0xFCEE, "M", "نم"),
-        (0xFCEF, "M", "نه"),
-        (0xFCF0, "M", "يم"),
-        (0xFCF1, "M", "يه"),
-        (0xFCF2, "M", "ـَّ"),
-        (0xFCF3, "M", "ـُّ"),
-        (0xFCF4, "M", "ـِّ"),
-        (0xFCF5, "M", "طى"),
-        (0xFCF6, "M", "طي"),
-        (0xFCF7, "M", "عى"),
-        (0xFCF8, "M", "عي"),
-        (0xFCF9, "M", "غى"),
-        (0xFCFA, "M", "غي"),
-        (0xFCFB, "M", "سى"),
-        (0xFCFC, "M", "سي"),
-        (0xFCFD, "M", "شى"),
-        (0xFCFE, "M", "شي"),
-        (0xFCFF, "M", "حى"),
-        (0xFD00, "M", "حي"),
-        (0xFD01, "M", "جى"),
-        (0xFD02, "M", "جي"),
-        (0xFD03, "M", "خى"),
-        (0xFD04, "M", "خي"),
-        (0xFD05, "M", "صى"),
-        (0xFD06, "M", "صي"),
-        (0xFD07, "M", "ضى"),
-        (0xFD08, "M", "ضي"),
-        (0xFD09, "M", "شج"),
-        (0xFD0A, "M", "شح"),
-        (0xFD0B, "M", "شخ"),
-        (0xFD0C, "M", "شم"),
-        (0xFD0D, "M", "شر"),
-        (0xFD0E, "M", "سر"),
-        (0xFD0F, "M", "صر"),
-        (0xFD10, "M", "ضر"),
-        (0xFD11, "M", "طى"),
-        (0xFD12, "M", "طي"),
-        (0xFD13, "M", "عى"),
-        (0xFD14, "M", "عي"),
-        (0xFD15, "M", "غى"),
-        (0xFD16, "M", "غي"),
-        (0xFD17, "M", "سى"),
-        (0xFD18, "M", "سي"),
-        (0xFD19, "M", "شى"),
-        (0xFD1A, "M", "شي"),
-        (0xFD1B, "M", "حى"),
-        (0xFD1C, "M", "حي"),
-        (0xFD1D, "M", "جى"),
-        (0xFD1E, "M", "جي"),
-        (0xFD1F, "M", "خى"),
-        (0xFD20, "M", "خي"),
-        (0xFD21, "M", "صى"),
-        (0xFD22, "M", "صي"),
-        (0xFD23, "M", "ضى"),
-        (0xFD24, "M", "ضي"),
-        (0xFD25, "M", "شج"),
-        (0xFD26, "M", "شح"),
-        (0xFD27, "M", "شخ"),
-    ]
-
-
-def _seg_48():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFD28, "M", "شم"),
-        (0xFD29, "M", "شر"),
-        (0xFD2A, "M", "سر"),
-        (0xFD2B, "M", "صر"),
-        (0xFD2C, "M", "ضر"),
-        (0xFD2D, "M", "شج"),
-        (0xFD2E, "M", "شح"),
-        (0xFD2F, "M", "شخ"),
-        (0xFD30, "M", "شم"),
-        (0xFD31, "M", "سه"),
-        (0xFD32, "M", "شه"),
-        (0xFD33, "M", "طم"),
-        (0xFD34, "M", "سج"),
-        (0xFD35, "M", "سح"),
-        (0xFD36, "M", "سخ"),
-        (0xFD37, "M", "شج"),
-        (0xFD38, "M", "شح"),
-        (0xFD39, "M", "شخ"),
-        (0xFD3A, "M", "طم"),
-        (0xFD3B, "M", "ظم"),
-        (0xFD3C, "M", "اً"),
-        (0xFD3E, "V"),
-        (0xFD40, "X"),
-        (0xFD50, "M", "تجم"),
-        (0xFD51, "M", "تحج"),
-        (0xFD53, "M", "تحم"),
-        (0xFD54, "M", "تخم"),
-        (0xFD55, "M", "تمج"),
-        (0xFD56, "M", "تمح"),
-        (0xFD57, "M", "تمخ"),
-        (0xFD58, "M", "جمح"),
-        (0xFD5A, "M", "حمي"),
-        (0xFD5B, "M", "حمى"),
-        (0xFD5C, "M", "سحج"),
-        (0xFD5D, "M", "سجح"),
-        (0xFD5E, "M", "سجى"),
-        (0xFD5F, "M", "سمح"),
-        (0xFD61, "M", "سمج"),
-        (0xFD62, "M", "سمم"),
-        (0xFD64, "M", "صحح"),
-        (0xFD66, "M", "صمم"),
-        (0xFD67, "M", "شحم"),
-        (0xFD69, "M", "شجي"),
-        (0xFD6A, "M", "شمخ"),
-        (0xFD6C, "M", "شمم"),
-        (0xFD6E, "M", "ضحى"),
-        (0xFD6F, "M", "ضخم"),
-        (0xFD71, "M", "طمح"),
-        (0xFD73, "M", "طمم"),
-        (0xFD74, "M", "طمي"),
-        (0xFD75, "M", "عجم"),
-        (0xFD76, "M", "عمم"),
-        (0xFD78, "M", "عمى"),
-        (0xFD79, "M", "غمم"),
-        (0xFD7A, "M", "غمي"),
-        (0xFD7B, "M", "غمى"),
-        (0xFD7C, "M", "فخم"),
-        (0xFD7E, "M", "قمح"),
-        (0xFD7F, "M", "قمم"),
-        (0xFD80, "M", "لحم"),
-        (0xFD81, "M", "لحي"),
-        (0xFD82, "M", "لحى"),
-        (0xFD83, "M", "لجج"),
-        (0xFD85, "M", "لخم"),
-        (0xFD87, "M", "لمح"),
-        (0xFD89, "M", "محج"),
-        (0xFD8A, "M", "محم"),
-        (0xFD8B, "M", "محي"),
-        (0xFD8C, "M", "مجح"),
-        (0xFD8D, "M", "مجم"),
-        (0xFD8E, "M", "مخج"),
-        (0xFD8F, "M", "مخم"),
-        (0xFD90, "X"),
-        (0xFD92, "M", "مجخ"),
-        (0xFD93, "M", "همج"),
-        (0xFD94, "M", "همم"),
-        (0xFD95, "M", "نحم"),
-        (0xFD96, "M", "نحى"),
-        (0xFD97, "M", "نجم"),
-        (0xFD99, "M", "نجى"),
-        (0xFD9A, "M", "نمي"),
-        (0xFD9B, "M", "نمى"),
-        (0xFD9C, "M", "يمم"),
-        (0xFD9E, "M", "بخي"),
-        (0xFD9F, "M", "تجي"),
-        (0xFDA0, "M", "تجى"),
-        (0xFDA1, "M", "تخي"),
-        (0xFDA2, "M", "تخى"),
-        (0xFDA3, "M", "تمي"),
-        (0xFDA4, "M", "تمى"),
-        (0xFDA5, "M", "جمي"),
-        (0xFDA6, "M", "جحى"),
-        (0xFDA7, "M", "جمى"),
-        (0xFDA8, "M", "سخى"),
-        (0xFDA9, "M", "صحي"),
-        (0xFDAA, "M", "شحي"),
-        (0xFDAB, "M", "ضحي"),
-        (0xFDAC, "M", "لجي"),
-        (0xFDAD, "M", "لمي"),
-        (0xFDAE, "M", "يحي"),
-    ]
-
-
-def _seg_49():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFDAF, "M", "يجي"),
-        (0xFDB0, "M", "يمي"),
-        (0xFDB1, "M", "ممي"),
-        (0xFDB2, "M", "قمي"),
-        (0xFDB3, "M", "نحي"),
-        (0xFDB4, "M", "قمح"),
-        (0xFDB5, "M", "لحم"),
-        (0xFDB6, "M", "عمي"),
-        (0xFDB7, "M", "كمي"),
-        (0xFDB8, "M", "نجح"),
-        (0xFDB9, "M", "مخي"),
-        (0xFDBA, "M", "لجم"),
-        (0xFDBB, "M", "كمم"),
-        (0xFDBC, "M", "لجم"),
-        (0xFDBD, "M", "نجح"),
-        (0xFDBE, "M", "جحي"),
-        (0xFDBF, "M", "حجي"),
-        (0xFDC0, "M", "مجي"),
-        (0xFDC1, "M", "فمي"),
-        (0xFDC2, "M", "بحي"),
-        (0xFDC3, "M", "كمم"),
-        (0xFDC4, "M", "عجم"),
-        (0xFDC5, "M", "صمم"),
-        (0xFDC6, "M", "سخي"),
-        (0xFDC7, "M", "نجي"),
-        (0xFDC8, "X"),
-        (0xFDF0, "M", "صلے"),
-        (0xFDF1, "M", "قلے"),
-        (0xFDF2, "M", "الله"),
-        (0xFDF3, "M", "اكبر"),
-        (0xFDF4, "M", "محمد"),
-        (0xFDF5, "M", "صلعم"),
-        (0xFDF6, "M", "رسول"),
-        (0xFDF7, "M", "عليه"),
-        (0xFDF8, "M", "وسلم"),
-        (0xFDF9, "M", "صلى"),
-        (0xFDFA, "3", "صلى الله عليه وسلم"),
-        (0xFDFB, "3", "جل جلاله"),
-        (0xFDFC, "M", "ریال"),
-        (0xFDFD, "V"),
-        (0xFDFE, "X"),
-        (0xFE00, "I"),
-        (0xFE10, "3", ","),
-        (0xFE11, "M", "、"),
-        (0xFE12, "X"),
-        (0xFE13, "3", ":"),
-        (0xFE14, "3", ";"),
-        (0xFE15, "3", "!"),
-        (0xFE16, "3", "?"),
-        (0xFE17, "M", "〖"),
-        (0xFE18, "M", "〗"),
-        (0xFE19, "X"),
-        (0xFE20, "V"),
-        (0xFE30, "X"),
-        (0xFE31, "M", "—"),
-        (0xFE32, "M", "–"),
-        (0xFE33, "3", "_"),
-        (0xFE35, "3", "("),
-        (0xFE36, "3", ")"),
-        (0xFE37, "3", "{"),
-        (0xFE38, "3", "}"),
-        (0xFE39, "M", "〔"),
-        (0xFE3A, "M", "〕"),
-        (0xFE3B, "M", "【"),
-        (0xFE3C, "M", "】"),
-        (0xFE3D, "M", "《"),
-        (0xFE3E, "M", "》"),
-        (0xFE3F, "M", "〈"),
-        (0xFE40, "M", "〉"),
-        (0xFE41, "M", "「"),
-        (0xFE42, "M", "」"),
-        (0xFE43, "M", "『"),
-        (0xFE44, "M", "』"),
-        (0xFE45, "V"),
-        (0xFE47, "3", "["),
-        (0xFE48, "3", "]"),
-        (0xFE49, "3", " ̅"),
-        (0xFE4D, "3", "_"),
-        (0xFE50, "3", ","),
-        (0xFE51, "M", "、"),
-        (0xFE52, "X"),
-        (0xFE54, "3", ";"),
-        (0xFE55, "3", ":"),
-        (0xFE56, "3", "?"),
-        (0xFE57, "3", "!"),
-        (0xFE58, "M", "—"),
-        (0xFE59, "3", "("),
-        (0xFE5A, "3", ")"),
-        (0xFE5B, "3", "{"),
-        (0xFE5C, "3", "}"),
-        (0xFE5D, "M", "〔"),
-        (0xFE5E, "M", "〕"),
-        (0xFE5F, "3", "#"),
-        (0xFE60, "3", "&"),
-        (0xFE61, "3", "*"),
-        (0xFE62, "3", "+"),
-        (0xFE63, "M", "-"),
-        (0xFE64, "3", "<"),
-        (0xFE65, "3", ">"),
-        (0xFE66, "3", "="),
-    ]
-
-
-def _seg_50():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFE67, "X"),
-        (0xFE68, "3", "\\"),
-        (0xFE69, "3", "$"),
-        (0xFE6A, "3", "%"),
-        (0xFE6B, "3", "@"),
-        (0xFE6C, "X"),
-        (0xFE70, "3", " ً"),
-        (0xFE71, "M", "ـً"),
-        (0xFE72, "3", " ٌ"),
-        (0xFE73, "V"),
-        (0xFE74, "3", " ٍ"),
-        (0xFE75, "X"),
-        (0xFE76, "3", " َ"),
-        (0xFE77, "M", "ـَ"),
-        (0xFE78, "3", " ُ"),
-        (0xFE79, "M", "ـُ"),
-        (0xFE7A, "3", " ِ"),
-        (0xFE7B, "M", "ـِ"),
-        (0xFE7C, "3", " ّ"),
-        (0xFE7D, "M", "ـّ"),
-        (0xFE7E, "3", " ْ"),
-        (0xFE7F, "M", "ـْ"),
-        (0xFE80, "M", "ء"),
-        (0xFE81, "M", "آ"),
-        (0xFE83, "M", "أ"),
-        (0xFE85, "M", "ؤ"),
-        (0xFE87, "M", "إ"),
-        (0xFE89, "M", "ئ"),
-        (0xFE8D, "M", "ا"),
-        (0xFE8F, "M", "ب"),
-        (0xFE93, "M", "ة"),
-        (0xFE95, "M", "ت"),
-        (0xFE99, "M", "ث"),
-        (0xFE9D, "M", "ج"),
-        (0xFEA1, "M", "ح"),
-        (0xFEA5, "M", "خ"),
-        (0xFEA9, "M", "د"),
-        (0xFEAB, "M", "ذ"),
-        (0xFEAD, "M", "ر"),
-        (0xFEAF, "M", "ز"),
-        (0xFEB1, "M", "س"),
-        (0xFEB5, "M", "ش"),
-        (0xFEB9, "M", "ص"),
-        (0xFEBD, "M", "ض"),
-        (0xFEC1, "M", "ط"),
-        (0xFEC5, "M", "ظ"),
-        (0xFEC9, "M", "ع"),
-        (0xFECD, "M", "غ"),
-        (0xFED1, "M", "ف"),
-        (0xFED5, "M", "ق"),
-        (0xFED9, "M", "ك"),
-        (0xFEDD, "M", "ل"),
-        (0xFEE1, "M", "م"),
-        (0xFEE5, "M", "ن"),
-        (0xFEE9, "M", "ه"),
-        (0xFEED, "M", "و"),
-        (0xFEEF, "M", "ى"),
-        (0xFEF1, "M", "ي"),
-        (0xFEF5, "M", "لآ"),
-        (0xFEF7, "M", "لأ"),
-        (0xFEF9, "M", "لإ"),
-        (0xFEFB, "M", "لا"),
-        (0xFEFD, "X"),
-        (0xFEFF, "I"),
-        (0xFF00, "X"),
-        (0xFF01, "3", "!"),
-        (0xFF02, "3", '"'),
-        (0xFF03, "3", "#"),
-        (0xFF04, "3", "$"),
-        (0xFF05, "3", "%"),
-        (0xFF06, "3", "&"),
-        (0xFF07, "3", "'"),
-        (0xFF08, "3", "("),
-        (0xFF09, "3", ")"),
-        (0xFF0A, "3", "*"),
-        (0xFF0B, "3", "+"),
-        (0xFF0C, "3", ","),
-        (0xFF0D, "M", "-"),
-        (0xFF0E, "M", "."),
-        (0xFF0F, "3", "/"),
-        (0xFF10, "M", "0"),
-        (0xFF11, "M", "1"),
-        (0xFF12, "M", "2"),
-        (0xFF13, "M", "3"),
-        (0xFF14, "M", "4"),
-        (0xFF15, "M", "5"),
-        (0xFF16, "M", "6"),
-        (0xFF17, "M", "7"),
-        (0xFF18, "M", "8"),
-        (0xFF19, "M", "9"),
-        (0xFF1A, "3", ":"),
-        (0xFF1B, "3", ";"),
-        (0xFF1C, "3", "<"),
-        (0xFF1D, "3", "="),
-        (0xFF1E, "3", ">"),
-        (0xFF1F, "3", "?"),
-        (0xFF20, "3", "@"),
-        (0xFF21, "M", "a"),
-        (0xFF22, "M", "b"),
-        (0xFF23, "M", "c"),
-    ]
-
-
-def _seg_51():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFF24, "M", "d"),
-        (0xFF25, "M", "e"),
-        (0xFF26, "M", "f"),
-        (0xFF27, "M", "g"),
-        (0xFF28, "M", "h"),
-        (0xFF29, "M", "i"),
-        (0xFF2A, "M", "j"),
-        (0xFF2B, "M", "k"),
-        (0xFF2C, "M", "l"),
-        (0xFF2D, "M", "m"),
-        (0xFF2E, "M", "n"),
-        (0xFF2F, "M", "o"),
-        (0xFF30, "M", "p"),
-        (0xFF31, "M", "q"),
-        (0xFF32, "M", "r"),
-        (0xFF33, "M", "s"),
-        (0xFF34, "M", "t"),
-        (0xFF35, "M", "u"),
-        (0xFF36, "M", "v"),
-        (0xFF37, "M", "w"),
-        (0xFF38, "M", "x"),
-        (0xFF39, "M", "y"),
-        (0xFF3A, "M", "z"),
-        (0xFF3B, "3", "["),
-        (0xFF3C, "3", "\\"),
-        (0xFF3D, "3", "]"),
-        (0xFF3E, "3", "^"),
-        (0xFF3F, "3", "_"),
-        (0xFF40, "3", "`"),
-        (0xFF41, "M", "a"),
-        (0xFF42, "M", "b"),
-        (0xFF43, "M", "c"),
-        (0xFF44, "M", "d"),
-        (0xFF45, "M", "e"),
-        (0xFF46, "M", "f"),
-        (0xFF47, "M", "g"),
-        (0xFF48, "M", "h"),
-        (0xFF49, "M", "i"),
-        (0xFF4A, "M", "j"),
-        (0xFF4B, "M", "k"),
-        (0xFF4C, "M", "l"),
-        (0xFF4D, "M", "m"),
-        (0xFF4E, "M", "n"),
-        (0xFF4F, "M", "o"),
-        (0xFF50, "M", "p"),
-        (0xFF51, "M", "q"),
-        (0xFF52, "M", "r"),
-        (0xFF53, "M", "s"),
-        (0xFF54, "M", "t"),
-        (0xFF55, "M", "u"),
-        (0xFF56, "M", "v"),
-        (0xFF57, "M", "w"),
-        (0xFF58, "M", "x"),
-        (0xFF59, "M", "y"),
-        (0xFF5A, "M", "z"),
-        (0xFF5B, "3", "{"),
-        (0xFF5C, "3", "|"),
-        (0xFF5D, "3", "}"),
-        (0xFF5E, "3", "~"),
-        (0xFF5F, "M", "⦅"),
-        (0xFF60, "M", "⦆"),
-        (0xFF61, "M", "."),
-        (0xFF62, "M", "「"),
-        (0xFF63, "M", "」"),
-        (0xFF64, "M", "、"),
-        (0xFF65, "M", "・"),
-        (0xFF66, "M", "ヲ"),
-        (0xFF67, "M", "ァ"),
-        (0xFF68, "M", "ィ"),
-        (0xFF69, "M", "ゥ"),
-        (0xFF6A, "M", "ェ"),
-        (0xFF6B, "M", "ォ"),
-        (0xFF6C, "M", "ャ"),
-        (0xFF6D, "M", "ュ"),
-        (0xFF6E, "M", "ョ"),
-        (0xFF6F, "M", "ッ"),
-        (0xFF70, "M", "ー"),
-        (0xFF71, "M", "ア"),
-        (0xFF72, "M", "イ"),
-        (0xFF73, "M", "ウ"),
-        (0xFF74, "M", "エ"),
-        (0xFF75, "M", "オ"),
-        (0xFF76, "M", "カ"),
-        (0xFF77, "M", "キ"),
-        (0xFF78, "M", "ク"),
-        (0xFF79, "M", "ケ"),
-        (0xFF7A, "M", "コ"),
-        (0xFF7B, "M", "サ"),
-        (0xFF7C, "M", "シ"),
-        (0xFF7D, "M", "ス"),
-        (0xFF7E, "M", "セ"),
-        (0xFF7F, "M", "ソ"),
-        (0xFF80, "M", "タ"),
-        (0xFF81, "M", "チ"),
-        (0xFF82, "M", "ツ"),
-        (0xFF83, "M", "テ"),
-        (0xFF84, "M", "ト"),
-        (0xFF85, "M", "ナ"),
-        (0xFF86, "M", "ニ"),
-        (0xFF87, "M", "ヌ"),
-    ]
-
-
-def _seg_52():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0xFF88, "M", "ネ"),
-        (0xFF89, "M", "ノ"),
-        (0xFF8A, "M", "ハ"),
-        (0xFF8B, "M", "ヒ"),
-        (0xFF8C, "M", "フ"),
-        (0xFF8D, "M", "ヘ"),
-        (0xFF8E, "M", "ホ"),
-        (0xFF8F, "M", "マ"),
-        (0xFF90, "M", "ミ"),
-        (0xFF91, "M", "ム"),
-        (0xFF92, "M", "メ"),
-        (0xFF93, "M", "モ"),
-        (0xFF94, "M", "ヤ"),
-        (0xFF95, "M", "ユ"),
-        (0xFF96, "M", "ヨ"),
-        (0xFF97, "M", "ラ"),
-        (0xFF98, "M", "リ"),
-        (0xFF99, "M", "ル"),
-        (0xFF9A, "M", "レ"),
-        (0xFF9B, "M", "ロ"),
-        (0xFF9C, "M", "ワ"),
-        (0xFF9D, "M", "ン"),
-        (0xFF9E, "M", "゙"),
-        (0xFF9F, "M", "゚"),
-        (0xFFA0, "X"),
-        (0xFFA1, "M", "ᄀ"),
-        (0xFFA2, "M", "ᄁ"),
-        (0xFFA3, "M", "ᆪ"),
-        (0xFFA4, "M", "ᄂ"),
-        (0xFFA5, "M", "ᆬ"),
-        (0xFFA6, "M", "ᆭ"),
-        (0xFFA7, "M", "ᄃ"),
-        (0xFFA8, "M", "ᄄ"),
-        (0xFFA9, "M", "ᄅ"),
-        (0xFFAA, "M", "ᆰ"),
-        (0xFFAB, "M", "ᆱ"),
-        (0xFFAC, "M", "ᆲ"),
-        (0xFFAD, "M", "ᆳ"),
-        (0xFFAE, "M", "ᆴ"),
-        (0xFFAF, "M", "ᆵ"),
-        (0xFFB0, "M", "ᄚ"),
-        (0xFFB1, "M", "ᄆ"),
-        (0xFFB2, "M", "ᄇ"),
-        (0xFFB3, "M", "ᄈ"),
-        (0xFFB4, "M", "ᄡ"),
-        (0xFFB5, "M", "ᄉ"),
-        (0xFFB6, "M", "ᄊ"),
-        (0xFFB7, "M", "ᄋ"),
-        (0xFFB8, "M", "ᄌ"),
-        (0xFFB9, "M", "ᄍ"),
-        (0xFFBA, "M", "ᄎ"),
-        (0xFFBB, "M", "ᄏ"),
-        (0xFFBC, "M", "ᄐ"),
-        (0xFFBD, "M", "ᄑ"),
-        (0xFFBE, "M", "ᄒ"),
-        (0xFFBF, "X"),
-        (0xFFC2, "M", "ᅡ"),
-        (0xFFC3, "M", "ᅢ"),
-        (0xFFC4, "M", "ᅣ"),
-        (0xFFC5, "M", "ᅤ"),
-        (0xFFC6, "M", "ᅥ"),
-        (0xFFC7, "M", "ᅦ"),
-        (0xFFC8, "X"),
-        (0xFFCA, "M", "ᅧ"),
-        (0xFFCB, "M", "ᅨ"),
-        (0xFFCC, "M", "ᅩ"),
-        (0xFFCD, "M", "ᅪ"),
-        (0xFFCE, "M", "ᅫ"),
-        (0xFFCF, "M", "ᅬ"),
-        (0xFFD0, "X"),
-        (0xFFD2, "M", "ᅭ"),
-        (0xFFD3, "M", "ᅮ"),
-        (0xFFD4, "M", "ᅯ"),
-        (0xFFD5, "M", "ᅰ"),
-        (0xFFD6, "M", "ᅱ"),
-        (0xFFD7, "M", "ᅲ"),
-        (0xFFD8, "X"),
-        (0xFFDA, "M", "ᅳ"),
-        (0xFFDB, "M", "ᅴ"),
-        (0xFFDC, "M", "ᅵ"),
-        (0xFFDD, "X"),
-        (0xFFE0, "M", "¢"),
-        (0xFFE1, "M", "£"),
-        (0xFFE2, "M", "¬"),
-        (0xFFE3, "3", " ̄"),
-        (0xFFE4, "M", "¦"),
-        (0xFFE5, "M", "¥"),
-        (0xFFE6, "M", "₩"),
-        (0xFFE7, "X"),
-        (0xFFE8, "M", "│"),
-        (0xFFE9, "M", "←"),
-        (0xFFEA, "M", "↑"),
-        (0xFFEB, "M", "→"),
-        (0xFFEC, "M", "↓"),
-        (0xFFED, "M", "■"),
-        (0xFFEE, "M", "○"),
-        (0xFFEF, "X"),
-        (0x10000, "V"),
-        (0x1000C, "X"),
-        (0x1000D, "V"),
-    ]
-
-
-def _seg_53():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x10027, "X"),
-        (0x10028, "V"),
-        (0x1003B, "X"),
-        (0x1003C, "V"),
-        (0x1003E, "X"),
-        (0x1003F, "V"),
-        (0x1004E, "X"),
-        (0x10050, "V"),
-        (0x1005E, "X"),
-        (0x10080, "V"),
-        (0x100FB, "X"),
-        (0x10100, "V"),
-        (0x10103, "X"),
-        (0x10107, "V"),
-        (0x10134, "X"),
-        (0x10137, "V"),
-        (0x1018F, "X"),
-        (0x10190, "V"),
-        (0x1019D, "X"),
-        (0x101A0, "V"),
-        (0x101A1, "X"),
-        (0x101D0, "V"),
-        (0x101FE, "X"),
-        (0x10280, "V"),
-        (0x1029D, "X"),
-        (0x102A0, "V"),
-        (0x102D1, "X"),
-        (0x102E0, "V"),
-        (0x102FC, "X"),
-        (0x10300, "V"),
-        (0x10324, "X"),
-        (0x1032D, "V"),
-        (0x1034B, "X"),
-        (0x10350, "V"),
-        (0x1037B, "X"),
-        (0x10380, "V"),
-        (0x1039E, "X"),
-        (0x1039F, "V"),
-        (0x103C4, "X"),
-        (0x103C8, "V"),
-        (0x103D6, "X"),
-        (0x10400, "M", "𐐨"),
-        (0x10401, "M", "𐐩"),
-        (0x10402, "M", "𐐪"),
-        (0x10403, "M", "𐐫"),
-        (0x10404, "M", "𐐬"),
-        (0x10405, "M", "𐐭"),
-        (0x10406, "M", "𐐮"),
-        (0x10407, "M", "𐐯"),
-        (0x10408, "M", "𐐰"),
-        (0x10409, "M", "𐐱"),
-        (0x1040A, "M", "𐐲"),
-        (0x1040B, "M", "𐐳"),
-        (0x1040C, "M", "𐐴"),
-        (0x1040D, "M", "𐐵"),
-        (0x1040E, "M", "𐐶"),
-        (0x1040F, "M", "𐐷"),
-        (0x10410, "M", "𐐸"),
-        (0x10411, "M", "𐐹"),
-        (0x10412, "M", "𐐺"),
-        (0x10413, "M", "𐐻"),
-        (0x10414, "M", "𐐼"),
-        (0x10415, "M", "𐐽"),
-        (0x10416, "M", "𐐾"),
-        (0x10417, "M", "𐐿"),
-        (0x10418, "M", "𐑀"),
-        (0x10419, "M", "𐑁"),
-        (0x1041A, "M", "𐑂"),
-        (0x1041B, "M", "𐑃"),
-        (0x1041C, "M", "𐑄"),
-        (0x1041D, "M", "𐑅"),
-        (0x1041E, "M", "𐑆"),
-        (0x1041F, "M", "𐑇"),
-        (0x10420, "M", "𐑈"),
-        (0x10421, "M", "𐑉"),
-        (0x10422, "M", "𐑊"),
-        (0x10423, "M", "𐑋"),
-        (0x10424, "M", "𐑌"),
-        (0x10425, "M", "𐑍"),
-        (0x10426, "M", "𐑎"),
-        (0x10427, "M", "𐑏"),
-        (0x10428, "V"),
-        (0x1049E, "X"),
-        (0x104A0, "V"),
-        (0x104AA, "X"),
-        (0x104B0, "M", "𐓘"),
-        (0x104B1, "M", "𐓙"),
-        (0x104B2, "M", "𐓚"),
-        (0x104B3, "M", "𐓛"),
-        (0x104B4, "M", "𐓜"),
-        (0x104B5, "M", "𐓝"),
-        (0x104B6, "M", "𐓞"),
-        (0x104B7, "M", "𐓟"),
-        (0x104B8, "M", "𐓠"),
-        (0x104B9, "M", "𐓡"),
-        (0x104BA, "M", "𐓢"),
-        (0x104BB, "M", "𐓣"),
-        (0x104BC, "M", "𐓤"),
-        (0x104BD, "M", "𐓥"),
-        (0x104BE, "M", "𐓦"),
-    ]
-
-
-def _seg_54():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x104BF, "M", "𐓧"),
-        (0x104C0, "M", "𐓨"),
-        (0x104C1, "M", "𐓩"),
-        (0x104C2, "M", "𐓪"),
-        (0x104C3, "M", "𐓫"),
-        (0x104C4, "M", "𐓬"),
-        (0x104C5, "M", "𐓭"),
-        (0x104C6, "M", "𐓮"),
-        (0x104C7, "M", "𐓯"),
-        (0x104C8, "M", "𐓰"),
-        (0x104C9, "M", "𐓱"),
-        (0x104CA, "M", "𐓲"),
-        (0x104CB, "M", "𐓳"),
-        (0x104CC, "M", "𐓴"),
-        (0x104CD, "M", "𐓵"),
-        (0x104CE, "M", "𐓶"),
-        (0x104CF, "M", "𐓷"),
-        (0x104D0, "M", "𐓸"),
-        (0x104D1, "M", "𐓹"),
-        (0x104D2, "M", "𐓺"),
-        (0x104D3, "M", "𐓻"),
-        (0x104D4, "X"),
-        (0x104D8, "V"),
-        (0x104FC, "X"),
-        (0x10500, "V"),
-        (0x10528, "X"),
-        (0x10530, "V"),
-        (0x10564, "X"),
-        (0x1056F, "V"),
-        (0x10570, "X"),
-        (0x10600, "V"),
-        (0x10737, "X"),
-        (0x10740, "V"),
-        (0x10756, "X"),
-        (0x10760, "V"),
-        (0x10768, "X"),
-        (0x10800, "V"),
-        (0x10806, "X"),
-        (0x10808, "V"),
-        (0x10809, "X"),
-        (0x1080A, "V"),
-        (0x10836, "X"),
-        (0x10837, "V"),
-        (0x10839, "X"),
-        (0x1083C, "V"),
-        (0x1083D, "X"),
-        (0x1083F, "V"),
-        (0x10856, "X"),
-        (0x10857, "V"),
-        (0x1089F, "X"),
-        (0x108A7, "V"),
-        (0x108B0, "X"),
-        (0x108E0, "V"),
-        (0x108F3, "X"),
-        (0x108F4, "V"),
-        (0x108F6, "X"),
-        (0x108FB, "V"),
-        (0x1091C, "X"),
-        (0x1091F, "V"),
-        (0x1093A, "X"),
-        (0x1093F, "V"),
-        (0x10940, "X"),
-        (0x10980, "V"),
-        (0x109B8, "X"),
-        (0x109BC, "V"),
-        (0x109D0, "X"),
-        (0x109D2, "V"),
-        (0x10A04, "X"),
-        (0x10A05, "V"),
-        (0x10A07, "X"),
-        (0x10A0C, "V"),
-        (0x10A14, "X"),
-        (0x10A15, "V"),
-        (0x10A18, "X"),
-        (0x10A19, "V"),
-        (0x10A36, "X"),
-        (0x10A38, "V"),
-        (0x10A3B, "X"),
-        (0x10A3F, "V"),
-        (0x10A49, "X"),
-        (0x10A50, "V"),
-        (0x10A59, "X"),
-        (0x10A60, "V"),
-        (0x10AA0, "X"),
-        (0x10AC0, "V"),
-        (0x10AE7, "X"),
-        (0x10AEB, "V"),
-        (0x10AF7, "X"),
-        (0x10B00, "V"),
-        (0x10B36, "X"),
-        (0x10B39, "V"),
-        (0x10B56, "X"),
-        (0x10B58, "V"),
-        (0x10B73, "X"),
-        (0x10B78, "V"),
-        (0x10B92, "X"),
-        (0x10B99, "V"),
-        (0x10B9D, "X"),
-        (0x10BA9, "V"),
-        (0x10BB0, "X"),
-    ]
-
-
-def _seg_55():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x10C00, "V"),
-        (0x10C49, "X"),
-        (0x10C80, "M", "𐳀"),
-        (0x10C81, "M", "𐳁"),
-        (0x10C82, "M", "𐳂"),
-        (0x10C83, "M", "𐳃"),
-        (0x10C84, "M", "𐳄"),
-        (0x10C85, "M", "𐳅"),
-        (0x10C86, "M", "𐳆"),
-        (0x10C87, "M", "𐳇"),
-        (0x10C88, "M", "𐳈"),
-        (0x10C89, "M", "𐳉"),
-        (0x10C8A, "M", "𐳊"),
-        (0x10C8B, "M", "𐳋"),
-        (0x10C8C, "M", "𐳌"),
-        (0x10C8D, "M", "𐳍"),
-        (0x10C8E, "M", "𐳎"),
-        (0x10C8F, "M", "𐳏"),
-        (0x10C90, "M", "𐳐"),
-        (0x10C91, "M", "𐳑"),
-        (0x10C92, "M", "𐳒"),
-        (0x10C93, "M", "𐳓"),
-        (0x10C94, "M", "𐳔"),
-        (0x10C95, "M", "𐳕"),
-        (0x10C96, "M", "𐳖"),
-        (0x10C97, "M", "𐳗"),
-        (0x10C98, "M", "𐳘"),
-        (0x10C99, "M", "𐳙"),
-        (0x10C9A, "M", "𐳚"),
-        (0x10C9B, "M", "𐳛"),
-        (0x10C9C, "M", "𐳜"),
-        (0x10C9D, "M", "𐳝"),
-        (0x10C9E, "M", "𐳞"),
-        (0x10C9F, "M", "𐳟"),
-        (0x10CA0, "M", "𐳠"),
-        (0x10CA1, "M", "𐳡"),
-        (0x10CA2, "M", "𐳢"),
-        (0x10CA3, "M", "𐳣"),
-        (0x10CA4, "M", "𐳤"),
-        (0x10CA5, "M", "𐳥"),
-        (0x10CA6, "M", "𐳦"),
-        (0x10CA7, "M", "𐳧"),
-        (0x10CA8, "M", "𐳨"),
-        (0x10CA9, "M", "𐳩"),
-        (0x10CAA, "M", "𐳪"),
-        (0x10CAB, "M", "𐳫"),
-        (0x10CAC, "M", "𐳬"),
-        (0x10CAD, "M", "𐳭"),
-        (0x10CAE, "M", "𐳮"),
-        (0x10CAF, "M", "𐳯"),
-        (0x10CB0, "M", "𐳰"),
-        (0x10CB1, "M", "𐳱"),
-        (0x10CB2, "M", "𐳲"),
-        (0x10CB3, "X"),
-        (0x10CC0, "V"),
-        (0x10CF3, "X"),
-        (0x10CFA, "V"),
-        (0x10D28, "X"),
-        (0x10D30, "V"),
-        (0x10D3A, "X"),
-        (0x10E60, "V"),
-        (0x10E7F, "X"),
-        (0x10E80, "V"),
-        (0x10EAA, "X"),
-        (0x10EAB, "V"),
-        (0x10EAE, "X"),
-        (0x10EB0, "V"),
-        (0x10EB2, "X"),
-        (0x10F00, "V"),
-        (0x10F28, "X"),
-        (0x10F30, "V"),
-        (0x10F5A, "X"),
-        (0x10FB0, "V"),
-        (0x10FCC, "X"),
-        (0x10FE0, "V"),
-        (0x10FF7, "X"),
-        (0x11000, "V"),
-        (0x1104E, "X"),
-        (0x11052, "V"),
-        (0x11070, "X"),
-        (0x1107F, "V"),
-        (0x110BD, "X"),
-        (0x110BE, "V"),
-        (0x110C2, "X"),
-        (0x110D0, "V"),
-        (0x110E9, "X"),
-        (0x110F0, "V"),
-        (0x110FA, "X"),
-        (0x11100, "V"),
-        (0x11135, "X"),
-        (0x11136, "V"),
-        (0x11148, "X"),
-        (0x11150, "V"),
-        (0x11177, "X"),
-        (0x11180, "V"),
-        (0x111E0, "X"),
-        (0x111E1, "V"),
-        (0x111F5, "X"),
-        (0x11200, "V"),
-        (0x11212, "X"),
-    ]
-
-
-def _seg_56():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x11213, "V"),
-        (0x1123F, "X"),
-        (0x11280, "V"),
-        (0x11287, "X"),
-        (0x11288, "V"),
-        (0x11289, "X"),
-        (0x1128A, "V"),
-        (0x1128E, "X"),
-        (0x1128F, "V"),
-        (0x1129E, "X"),
-        (0x1129F, "V"),
-        (0x112AA, "X"),
-        (0x112B0, "V"),
-        (0x112EB, "X"),
-        (0x112F0, "V"),
-        (0x112FA, "X"),
-        (0x11300, "V"),
-        (0x11304, "X"),
-        (0x11305, "V"),
-        (0x1130D, "X"),
-        (0x1130F, "V"),
-        (0x11311, "X"),
-        (0x11313, "V"),
-        (0x11329, "X"),
-        (0x1132A, "V"),
-        (0x11331, "X"),
-        (0x11332, "V"),
-        (0x11334, "X"),
-        (0x11335, "V"),
-        (0x1133A, "X"),
-        (0x1133B, "V"),
-        (0x11345, "X"),
-        (0x11347, "V"),
-        (0x11349, "X"),
-        (0x1134B, "V"),
-        (0x1134E, "X"),
-        (0x11350, "V"),
-        (0x11351, "X"),
-        (0x11357, "V"),
-        (0x11358, "X"),
-        (0x1135D, "V"),
-        (0x11364, "X"),
-        (0x11366, "V"),
-        (0x1136D, "X"),
-        (0x11370, "V"),
-        (0x11375, "X"),
-        (0x11400, "V"),
-        (0x1145C, "X"),
-        (0x1145D, "V"),
-        (0x11462, "X"),
-        (0x11480, "V"),
-        (0x114C8, "X"),
-        (0x114D0, "V"),
-        (0x114DA, "X"),
-        (0x11580, "V"),
-        (0x115B6, "X"),
-        (0x115B8, "V"),
-        (0x115DE, "X"),
-        (0x11600, "V"),
-        (0x11645, "X"),
-        (0x11650, "V"),
-        (0x1165A, "X"),
-        (0x11660, "V"),
-        (0x1166D, "X"),
-        (0x11680, "V"),
-        (0x116B9, "X"),
-        (0x116C0, "V"),
-        (0x116CA, "X"),
-        (0x11700, "V"),
-        (0x1171B, "X"),
-        (0x1171D, "V"),
-        (0x1172C, "X"),
-        (0x11730, "V"),
-        (0x11740, "X"),
-        (0x11800, "V"),
-        (0x1183C, "X"),
-        (0x118A0, "M", "𑣀"),
-        (0x118A1, "M", "𑣁"),
-        (0x118A2, "M", "𑣂"),
-        (0x118A3, "M", "𑣃"),
-        (0x118A4, "M", "𑣄"),
-        (0x118A5, "M", "𑣅"),
-        (0x118A6, "M", "𑣆"),
-        (0x118A7, "M", "𑣇"),
-        (0x118A8, "M", "𑣈"),
-        (0x118A9, "M", "𑣉"),
-        (0x118AA, "M", "𑣊"),
-        (0x118AB, "M", "𑣋"),
-        (0x118AC, "M", "𑣌"),
-        (0x118AD, "M", "𑣍"),
-        (0x118AE, "M", "𑣎"),
-        (0x118AF, "M", "𑣏"),
-        (0x118B0, "M", "𑣐"),
-        (0x118B1, "M", "𑣑"),
-        (0x118B2, "M", "𑣒"),
-        (0x118B3, "M", "𑣓"),
-        (0x118B4, "M", "𑣔"),
-        (0x118B5, "M", "𑣕"),
-        (0x118B6, "M", "𑣖"),
-        (0x118B7, "M", "𑣗"),
-    ]
-
-
-def _seg_57():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x118B8, "M", "𑣘"),
-        (0x118B9, "M", "𑣙"),
-        (0x118BA, "M", "𑣚"),
-        (0x118BB, "M", "𑣛"),
-        (0x118BC, "M", "𑣜"),
-        (0x118BD, "M", "𑣝"),
-        (0x118BE, "M", "𑣞"),
-        (0x118BF, "M", "𑣟"),
-        (0x118C0, "V"),
-        (0x118F3, "X"),
-        (0x118FF, "V"),
-        (0x11907, "X"),
-        (0x11909, "V"),
-        (0x1190A, "X"),
-        (0x1190C, "V"),
-        (0x11914, "X"),
-        (0x11915, "V"),
-        (0x11917, "X"),
-        (0x11918, "V"),
-        (0x11936, "X"),
-        (0x11937, "V"),
-        (0x11939, "X"),
-        (0x1193B, "V"),
-        (0x11947, "X"),
-        (0x11950, "V"),
-        (0x1195A, "X"),
-        (0x119A0, "V"),
-        (0x119A8, "X"),
-        (0x119AA, "V"),
-        (0x119D8, "X"),
-        (0x119DA, "V"),
-        (0x119E5, "X"),
-        (0x11A00, "V"),
-        (0x11A48, "X"),
-        (0x11A50, "V"),
-        (0x11AA3, "X"),
-        (0x11AC0, "V"),
-        (0x11AF9, "X"),
-        (0x11C00, "V"),
-        (0x11C09, "X"),
-        (0x11C0A, "V"),
-        (0x11C37, "X"),
-        (0x11C38, "V"),
-        (0x11C46, "X"),
-        (0x11C50, "V"),
-        (0x11C6D, "X"),
-        (0x11C70, "V"),
-        (0x11C90, "X"),
-        (0x11C92, "V"),
-        (0x11CA8, "X"),
-        (0x11CA9, "V"),
-        (0x11CB7, "X"),
-        (0x11D00, "V"),
-        (0x11D07, "X"),
-        (0x11D08, "V"),
-        (0x11D0A, "X"),
-        (0x11D0B, "V"),
-        (0x11D37, "X"),
-        (0x11D3A, "V"),
-        (0x11D3B, "X"),
-        (0x11D3C, "V"),
-        (0x11D3E, "X"),
-        (0x11D3F, "V"),
-        (0x11D48, "X"),
-        (0x11D50, "V"),
-        (0x11D5A, "X"),
-        (0x11D60, "V"),
-        (0x11D66, "X"),
-        (0x11D67, "V"),
-        (0x11D69, "X"),
-        (0x11D6A, "V"),
-        (0x11D8F, "X"),
-        (0x11D90, "V"),
-        (0x11D92, "X"),
-        (0x11D93, "V"),
-        (0x11D99, "X"),
-        (0x11DA0, "V"),
-        (0x11DAA, "X"),
-        (0x11EE0, "V"),
-        (0x11EF9, "X"),
-        (0x11FB0, "V"),
-        (0x11FB1, "X"),
-        (0x11FC0, "V"),
-        (0x11FF2, "X"),
-        (0x11FFF, "V"),
-        (0x1239A, "X"),
-        (0x12400, "V"),
-        (0x1246F, "X"),
-        (0x12470, "V"),
-        (0x12475, "X"),
-        (0x12480, "V"),
-        (0x12544, "X"),
-        (0x13000, "V"),
-        (0x1342F, "X"),
-        (0x14400, "V"),
-        (0x14647, "X"),
-        (0x16800, "V"),
-        (0x16A39, "X"),
-        (0x16A40, "V"),
-        (0x16A5F, "X"),
-    ]
-
-
-def _seg_58():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x16A60, "V"),
-        (0x16A6A, "X"),
-        (0x16A6E, "V"),
-        (0x16A70, "X"),
-        (0x16AD0, "V"),
-        (0x16AEE, "X"),
-        (0x16AF0, "V"),
-        (0x16AF6, "X"),
-        (0x16B00, "V"),
-        (0x16B46, "X"),
-        (0x16B50, "V"),
-        (0x16B5A, "X"),
-        (0x16B5B, "V"),
-        (0x16B62, "X"),
-        (0x16B63, "V"),
-        (0x16B78, "X"),
-        (0x16B7D, "V"),
-        (0x16B90, "X"),
-        (0x16E40, "M", "𖹠"),
-        (0x16E41, "M", "𖹡"),
-        (0x16E42, "M", "𖹢"),
-        (0x16E43, "M", "𖹣"),
-        (0x16E44, "M", "𖹤"),
-        (0x16E45, "M", "𖹥"),
-        (0x16E46, "M", "𖹦"),
-        (0x16E47, "M", "𖹧"),
-        (0x16E48, "M", "𖹨"),
-        (0x16E49, "M", "𖹩"),
-        (0x16E4A, "M", "𖹪"),
-        (0x16E4B, "M", "𖹫"),
-        (0x16E4C, "M", "𖹬"),
-        (0x16E4D, "M", "𖹭"),
-        (0x16E4E, "M", "𖹮"),
-        (0x16E4F, "M", "𖹯"),
-        (0x16E50, "M", "𖹰"),
-        (0x16E51, "M", "𖹱"),
-        (0x16E52, "M", "𖹲"),
-        (0x16E53, "M", "𖹳"),
-        (0x16E54, "M", "𖹴"),
-        (0x16E55, "M", "𖹵"),
-        (0x16E56, "M", "𖹶"),
-        (0x16E57, "M", "𖹷"),
-        (0x16E58, "M", "𖹸"),
-        (0x16E59, "M", "𖹹"),
-        (0x16E5A, "M", "𖹺"),
-        (0x16E5B, "M", "𖹻"),
-        (0x16E5C, "M", "𖹼"),
-        (0x16E5D, "M", "𖹽"),
-        (0x16E5E, "M", "𖹾"),
-        (0x16E5F, "M", "𖹿"),
-        (0x16E60, "V"),
-        (0x16E9B, "X"),
-        (0x16F00, "V"),
-        (0x16F4B, "X"),
-        (0x16F4F, "V"),
-        (0x16F88, "X"),
-        (0x16F8F, "V"),
-        (0x16FA0, "X"),
-        (0x16FE0, "V"),
-        (0x16FE5, "X"),
-        (0x16FF0, "V"),
-        (0x16FF2, "X"),
-        (0x17000, "V"),
-        (0x187F8, "X"),
-        (0x18800, "V"),
-        (0x18CD6, "X"),
-        (0x18D00, "V"),
-        (0x18D09, "X"),
-        (0x1B000, "V"),
-        (0x1B11F, "X"),
-        (0x1B150, "V"),
-        (0x1B153, "X"),
-        (0x1B164, "V"),
-        (0x1B168, "X"),
-        (0x1B170, "V"),
-        (0x1B2FC, "X"),
-        (0x1BC00, "V"),
-        (0x1BC6B, "X"),
-        (0x1BC70, "V"),
-        (0x1BC7D, "X"),
-        (0x1BC80, "V"),
-        (0x1BC89, "X"),
-        (0x1BC90, "V"),
-        (0x1BC9A, "X"),
-        (0x1BC9C, "V"),
-        (0x1BCA0, "I"),
-        (0x1BCA4, "X"),
-        (0x1D000, "V"),
-        (0x1D0F6, "X"),
-        (0x1D100, "V"),
-        (0x1D127, "X"),
-        (0x1D129, "V"),
-        (0x1D15E, "M", "𝅗𝅥"),
-        (0x1D15F, "M", "𝅘𝅥"),
-        (0x1D160, "M", "𝅘𝅥𝅮"),
-        (0x1D161, "M", "𝅘𝅥𝅯"),
-        (0x1D162, "M", "𝅘𝅥𝅰"),
-        (0x1D163, "M", "𝅘𝅥𝅱"),
-        (0x1D164, "M", "𝅘𝅥𝅲"),
-        (0x1D165, "V"),
-    ]
-
-
-def _seg_59():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D173, "X"),
-        (0x1D17B, "V"),
-        (0x1D1BB, "M", "𝆹𝅥"),
-        (0x1D1BC, "M", "𝆺𝅥"),
-        (0x1D1BD, "M", "𝆹𝅥𝅮"),
-        (0x1D1BE, "M", "𝆺𝅥𝅮"),
-        (0x1D1BF, "M", "𝆹𝅥𝅯"),
-        (0x1D1C0, "M", "𝆺𝅥𝅯"),
-        (0x1D1C1, "V"),
-        (0x1D1E9, "X"),
-        (0x1D200, "V"),
-        (0x1D246, "X"),
-        (0x1D2E0, "V"),
-        (0x1D2F4, "X"),
-        (0x1D300, "V"),
-        (0x1D357, "X"),
-        (0x1D360, "V"),
-        (0x1D379, "X"),
-        (0x1D400, "M", "a"),
-        (0x1D401, "M", "b"),
-        (0x1D402, "M", "c"),
-        (0x1D403, "M", "d"),
-        (0x1D404, "M", "e"),
-        (0x1D405, "M", "f"),
-        (0x1D406, "M", "g"),
-        (0x1D407, "M", "h"),
-        (0x1D408, "M", "i"),
-        (0x1D409, "M", "j"),
-        (0x1D40A, "M", "k"),
-        (0x1D40B, "M", "l"),
-        (0x1D40C, "M", "m"),
-        (0x1D40D, "M", "n"),
-        (0x1D40E, "M", "o"),
-        (0x1D40F, "M", "p"),
-        (0x1D410, "M", "q"),
-        (0x1D411, "M", "r"),
-        (0x1D412, "M", "s"),
-        (0x1D413, "M", "t"),
-        (0x1D414, "M", "u"),
-        (0x1D415, "M", "v"),
-        (0x1D416, "M", "w"),
-        (0x1D417, "M", "x"),
-        (0x1D418, "M", "y"),
-        (0x1D419, "M", "z"),
-        (0x1D41A, "M", "a"),
-        (0x1D41B, "M", "b"),
-        (0x1D41C, "M", "c"),
-        (0x1D41D, "M", "d"),
-        (0x1D41E, "M", "e"),
-        (0x1D41F, "M", "f"),
-        (0x1D420, "M", "g"),
-        (0x1D421, "M", "h"),
-        (0x1D422, "M", "i"),
-        (0x1D423, "M", "j"),
-        (0x1D424, "M", "k"),
-        (0x1D425, "M", "l"),
-        (0x1D426, "M", "m"),
-        (0x1D427, "M", "n"),
-        (0x1D428, "M", "o"),
-        (0x1D429, "M", "p"),
-        (0x1D42A, "M", "q"),
-        (0x1D42B, "M", "r"),
-        (0x1D42C, "M", "s"),
-        (0x1D42D, "M", "t"),
-        (0x1D42E, "M", "u"),
-        (0x1D42F, "M", "v"),
-        (0x1D430, "M", "w"),
-        (0x1D431, "M", "x"),
-        (0x1D432, "M", "y"),
-        (0x1D433, "M", "z"),
-        (0x1D434, "M", "a"),
-        (0x1D435, "M", "b"),
-        (0x1D436, "M", "c"),
-        (0x1D437, "M", "d"),
-        (0x1D438, "M", "e"),
-        (0x1D439, "M", "f"),
-        (0x1D43A, "M", "g"),
-        (0x1D43B, "M", "h"),
-        (0x1D43C, "M", "i"),
-        (0x1D43D, "M", "j"),
-        (0x1D43E, "M", "k"),
-        (0x1D43F, "M", "l"),
-        (0x1D440, "M", "m"),
-        (0x1D441, "M", "n"),
-        (0x1D442, "M", "o"),
-        (0x1D443, "M", "p"),
-        (0x1D444, "M", "q"),
-        (0x1D445, "M", "r"),
-        (0x1D446, "M", "s"),
-        (0x1D447, "M", "t"),
-        (0x1D448, "M", "u"),
-        (0x1D449, "M", "v"),
-        (0x1D44A, "M", "w"),
-        (0x1D44B, "M", "x"),
-        (0x1D44C, "M", "y"),
-        (0x1D44D, "M", "z"),
-        (0x1D44E, "M", "a"),
-        (0x1D44F, "M", "b"),
-        (0x1D450, "M", "c"),
-        (0x1D451, "M", "d"),
-    ]
-
-
-def _seg_60():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D452, "M", "e"),
-        (0x1D453, "M", "f"),
-        (0x1D454, "M", "g"),
-        (0x1D455, "X"),
-        (0x1D456, "M", "i"),
-        (0x1D457, "M", "j"),
-        (0x1D458, "M", "k"),
-        (0x1D459, "M", "l"),
-        (0x1D45A, "M", "m"),
-        (0x1D45B, "M", "n"),
-        (0x1D45C, "M", "o"),
-        (0x1D45D, "M", "p"),
-        (0x1D45E, "M", "q"),
-        (0x1D45F, "M", "r"),
-        (0x1D460, "M", "s"),
-        (0x1D461, "M", "t"),
-        (0x1D462, "M", "u"),
-        (0x1D463, "M", "v"),
-        (0x1D464, "M", "w"),
-        (0x1D465, "M", "x"),
-        (0x1D466, "M", "y"),
-        (0x1D467, "M", "z"),
-        (0x1D468, "M", "a"),
-        (0x1D469, "M", "b"),
-        (0x1D46A, "M", "c"),
-        (0x1D46B, "M", "d"),
-        (0x1D46C, "M", "e"),
-        (0x1D46D, "M", "f"),
-        (0x1D46E, "M", "g"),
-        (0x1D46F, "M", "h"),
-        (0x1D470, "M", "i"),
-        (0x1D471, "M", "j"),
-        (0x1D472, "M", "k"),
-        (0x1D473, "M", "l"),
-        (0x1D474, "M", "m"),
-        (0x1D475, "M", "n"),
-        (0x1D476, "M", "o"),
-        (0x1D477, "M", "p"),
-        (0x1D478, "M", "q"),
-        (0x1D479, "M", "r"),
-        (0x1D47A, "M", "s"),
-        (0x1D47B, "M", "t"),
-        (0x1D47C, "M", "u"),
-        (0x1D47D, "M", "v"),
-        (0x1D47E, "M", "w"),
-        (0x1D47F, "M", "x"),
-        (0x1D480, "M", "y"),
-        (0x1D481, "M", "z"),
-        (0x1D482, "M", "a"),
-        (0x1D483, "M", "b"),
-        (0x1D484, "M", "c"),
-        (0x1D485, "M", "d"),
-        (0x1D486, "M", "e"),
-        (0x1D487, "M", "f"),
-        (0x1D488, "M", "g"),
-        (0x1D489, "M", "h"),
-        (0x1D48A, "M", "i"),
-        (0x1D48B, "M", "j"),
-        (0x1D48C, "M", "k"),
-        (0x1D48D, "M", "l"),
-        (0x1D48E, "M", "m"),
-        (0x1D48F, "M", "n"),
-        (0x1D490, "M", "o"),
-        (0x1D491, "M", "p"),
-        (0x1D492, "M", "q"),
-        (0x1D493, "M", "r"),
-        (0x1D494, "M", "s"),
-        (0x1D495, "M", "t"),
-        (0x1D496, "M", "u"),
-        (0x1D497, "M", "v"),
-        (0x1D498, "M", "w"),
-        (0x1D499, "M", "x"),
-        (0x1D49A, "M", "y"),
-        (0x1D49B, "M", "z"),
-        (0x1D49C, "M", "a"),
-        (0x1D49D, "X"),
-        (0x1D49E, "M", "c"),
-        (0x1D49F, "M", "d"),
-        (0x1D4A0, "X"),
-        (0x1D4A2, "M", "g"),
-        (0x1D4A3, "X"),
-        (0x1D4A5, "M", "j"),
-        (0x1D4A6, "M", "k"),
-        (0x1D4A7, "X"),
-        (0x1D4A9, "M", "n"),
-        (0x1D4AA, "M", "o"),
-        (0x1D4AB, "M", "p"),
-        (0x1D4AC, "M", "q"),
-        (0x1D4AD, "X"),
-        (0x1D4AE, "M", "s"),
-        (0x1D4AF, "M", "t"),
-        (0x1D4B0, "M", "u"),
-        (0x1D4B1, "M", "v"),
-        (0x1D4B2, "M", "w"),
-        (0x1D4B3, "M", "x"),
-        (0x1D4B4, "M", "y"),
-        (0x1D4B5, "M", "z"),
-        (0x1D4B6, "M", "a"),
-        (0x1D4B7, "M", "b"),
-        (0x1D4B8, "M", "c"),
-    ]
-
-
-def _seg_61():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D4B9, "M", "d"),
-        (0x1D4BA, "X"),
-        (0x1D4BB, "M", "f"),
-        (0x1D4BC, "X"),
-        (0x1D4BD, "M", "h"),
-        (0x1D4BE, "M", "i"),
-        (0x1D4BF, "M", "j"),
-        (0x1D4C0, "M", "k"),
-        (0x1D4C1, "M", "l"),
-        (0x1D4C2, "M", "m"),
-        (0x1D4C3, "M", "n"),
-        (0x1D4C4, "X"),
-        (0x1D4C5, "M", "p"),
-        (0x1D4C6, "M", "q"),
-        (0x1D4C7, "M", "r"),
-        (0x1D4C8, "M", "s"),
-        (0x1D4C9, "M", "t"),
-        (0x1D4CA, "M", "u"),
-        (0x1D4CB, "M", "v"),
-        (0x1D4CC, "M", "w"),
-        (0x1D4CD, "M", "x"),
-        (0x1D4CE, "M", "y"),
-        (0x1D4CF, "M", "z"),
-        (0x1D4D0, "M", "a"),
-        (0x1D4D1, "M", "b"),
-        (0x1D4D2, "M", "c"),
-        (0x1D4D3, "M", "d"),
-        (0x1D4D4, "M", "e"),
-        (0x1D4D5, "M", "f"),
-        (0x1D4D6, "M", "g"),
-        (0x1D4D7, "M", "h"),
-        (0x1D4D8, "M", "i"),
-        (0x1D4D9, "M", "j"),
-        (0x1D4DA, "M", "k"),
-        (0x1D4DB, "M", "l"),
-        (0x1D4DC, "M", "m"),
-        (0x1D4DD, "M", "n"),
-        (0x1D4DE, "M", "o"),
-        (0x1D4DF, "M", "p"),
-        (0x1D4E0, "M", "q"),
-        (0x1D4E1, "M", "r"),
-        (0x1D4E2, "M", "s"),
-        (0x1D4E3, "M", "t"),
-        (0x1D4E4, "M", "u"),
-        (0x1D4E5, "M", "v"),
-        (0x1D4E6, "M", "w"),
-        (0x1D4E7, "M", "x"),
-        (0x1D4E8, "M", "y"),
-        (0x1D4E9, "M", "z"),
-        (0x1D4EA, "M", "a"),
-        (0x1D4EB, "M", "b"),
-        (0x1D4EC, "M", "c"),
-        (0x1D4ED, "M", "d"),
-        (0x1D4EE, "M", "e"),
-        (0x1D4EF, "M", "f"),
-        (0x1D4F0, "M", "g"),
-        (0x1D4F1, "M", "h"),
-        (0x1D4F2, "M", "i"),
-        (0x1D4F3, "M", "j"),
-        (0x1D4F4, "M", "k"),
-        (0x1D4F5, "M", "l"),
-        (0x1D4F6, "M", "m"),
-        (0x1D4F7, "M", "n"),
-        (0x1D4F8, "M", "o"),
-        (0x1D4F9, "M", "p"),
-        (0x1D4FA, "M", "q"),
-        (0x1D4FB, "M", "r"),
-        (0x1D4FC, "M", "s"),
-        (0x1D4FD, "M", "t"),
-        (0x1D4FE, "M", "u"),
-        (0x1D4FF, "M", "v"),
-        (0x1D500, "M", "w"),
-        (0x1D501, "M", "x"),
-        (0x1D502, "M", "y"),
-        (0x1D503, "M", "z"),
-        (0x1D504, "M", "a"),
-        (0x1D505, "M", "b"),
-        (0x1D506, "X"),
-        (0x1D507, "M", "d"),
-        (0x1D508, "M", "e"),
-        (0x1D509, "M", "f"),
-        (0x1D50A, "M", "g"),
-        (0x1D50B, "X"),
-        (0x1D50D, "M", "j"),
-        (0x1D50E, "M", "k"),
-        (0x1D50F, "M", "l"),
-        (0x1D510, "M", "m"),
-        (0x1D511, "M", "n"),
-        (0x1D512, "M", "o"),
-        (0x1D513, "M", "p"),
-        (0x1D514, "M", "q"),
-        (0x1D515, "X"),
-        (0x1D516, "M", "s"),
-        (0x1D517, "M", "t"),
-        (0x1D518, "M", "u"),
-        (0x1D519, "M", "v"),
-        (0x1D51A, "M", "w"),
-        (0x1D51B, "M", "x"),
-        (0x1D51C, "M", "y"),
-        (0x1D51D, "X"),
-    ]
-
-
-def _seg_62():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D51E, "M", "a"),
-        (0x1D51F, "M", "b"),
-        (0x1D520, "M", "c"),
-        (0x1D521, "M", "d"),
-        (0x1D522, "M", "e"),
-        (0x1D523, "M", "f"),
-        (0x1D524, "M", "g"),
-        (0x1D525, "M", "h"),
-        (0x1D526, "M", "i"),
-        (0x1D527, "M", "j"),
-        (0x1D528, "M", "k"),
-        (0x1D529, "M", "l"),
-        (0x1D52A, "M", "m"),
-        (0x1D52B, "M", "n"),
-        (0x1D52C, "M", "o"),
-        (0x1D52D, "M", "p"),
-        (0x1D52E, "M", "q"),
-        (0x1D52F, "M", "r"),
-        (0x1D530, "M", "s"),
-        (0x1D531, "M", "t"),
-        (0x1D532, "M", "u"),
-        (0x1D533, "M", "v"),
-        (0x1D534, "M", "w"),
-        (0x1D535, "M", "x"),
-        (0x1D536, "M", "y"),
-        (0x1D537, "M", "z"),
-        (0x1D538, "M", "a"),
-        (0x1D539, "M", "b"),
-        (0x1D53A, "X"),
-        (0x1D53B, "M", "d"),
-        (0x1D53C, "M", "e"),
-        (0x1D53D, "M", "f"),
-        (0x1D53E, "M", "g"),
-        (0x1D53F, "X"),
-        (0x1D540, "M", "i"),
-        (0x1D541, "M", "j"),
-        (0x1D542, "M", "k"),
-        (0x1D543, "M", "l"),
-        (0x1D544, "M", "m"),
-        (0x1D545, "X"),
-        (0x1D546, "M", "o"),
-        (0x1D547, "X"),
-        (0x1D54A, "M", "s"),
-        (0x1D54B, "M", "t"),
-        (0x1D54C, "M", "u"),
-        (0x1D54D, "M", "v"),
-        (0x1D54E, "M", "w"),
-        (0x1D54F, "M", "x"),
-        (0x1D550, "M", "y"),
-        (0x1D551, "X"),
-        (0x1D552, "M", "a"),
-        (0x1D553, "M", "b"),
-        (0x1D554, "M", "c"),
-        (0x1D555, "M", "d"),
-        (0x1D556, "M", "e"),
-        (0x1D557, "M", "f"),
-        (0x1D558, "M", "g"),
-        (0x1D559, "M", "h"),
-        (0x1D55A, "M", "i"),
-        (0x1D55B, "M", "j"),
-        (0x1D55C, "M", "k"),
-        (0x1D55D, "M", "l"),
-        (0x1D55E, "M", "m"),
-        (0x1D55F, "M", "n"),
-        (0x1D560, "M", "o"),
-        (0x1D561, "M", "p"),
-        (0x1D562, "M", "q"),
-        (0x1D563, "M", "r"),
-        (0x1D564, "M", "s"),
-        (0x1D565, "M", "t"),
-        (0x1D566, "M", "u"),
-        (0x1D567, "M", "v"),
-        (0x1D568, "M", "w"),
-        (0x1D569, "M", "x"),
-        (0x1D56A, "M", "y"),
-        (0x1D56B, "M", "z"),
-        (0x1D56C, "M", "a"),
-        (0x1D56D, "M", "b"),
-        (0x1D56E, "M", "c"),
-        (0x1D56F, "M", "d"),
-        (0x1D570, "M", "e"),
-        (0x1D571, "M", "f"),
-        (0x1D572, "M", "g"),
-        (0x1D573, "M", "h"),
-        (0x1D574, "M", "i"),
-        (0x1D575, "M", "j"),
-        (0x1D576, "M", "k"),
-        (0x1D577, "M", "l"),
-        (0x1D578, "M", "m"),
-        (0x1D579, "M", "n"),
-        (0x1D57A, "M", "o"),
-        (0x1D57B, "M", "p"),
-        (0x1D57C, "M", "q"),
-        (0x1D57D, "M", "r"),
-        (0x1D57E, "M", "s"),
-        (0x1D57F, "M", "t"),
-        (0x1D580, "M", "u"),
-        (0x1D581, "M", "v"),
-        (0x1D582, "M", "w"),
-        (0x1D583, "M", "x"),
-    ]
-
-
-def _seg_63():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D584, "M", "y"),
-        (0x1D585, "M", "z"),
-        (0x1D586, "M", "a"),
-        (0x1D587, "M", "b"),
-        (0x1D588, "M", "c"),
-        (0x1D589, "M", "d"),
-        (0x1D58A, "M", "e"),
-        (0x1D58B, "M", "f"),
-        (0x1D58C, "M", "g"),
-        (0x1D58D, "M", "h"),
-        (0x1D58E, "M", "i"),
-        (0x1D58F, "M", "j"),
-        (0x1D590, "M", "k"),
-        (0x1D591, "M", "l"),
-        (0x1D592, "M", "m"),
-        (0x1D593, "M", "n"),
-        (0x1D594, "M", "o"),
-        (0x1D595, "M", "p"),
-        (0x1D596, "M", "q"),
-        (0x1D597, "M", "r"),
-        (0x1D598, "M", "s"),
-        (0x1D599, "M", "t"),
-        (0x1D59A, "M", "u"),
-        (0x1D59B, "M", "v"),
-        (0x1D59C, "M", "w"),
-        (0x1D59D, "M", "x"),
-        (0x1D59E, "M", "y"),
-        (0x1D59F, "M", "z"),
-        (0x1D5A0, "M", "a"),
-        (0x1D5A1, "M", "b"),
-        (0x1D5A2, "M", "c"),
-        (0x1D5A3, "M", "d"),
-        (0x1D5A4, "M", "e"),
-        (0x1D5A5, "M", "f"),
-        (0x1D5A6, "M", "g"),
-        (0x1D5A7, "M", "h"),
-        (0x1D5A8, "M", "i"),
-        (0x1D5A9, "M", "j"),
-        (0x1D5AA, "M", "k"),
-        (0x1D5AB, "M", "l"),
-        (0x1D5AC, "M", "m"),
-        (0x1D5AD, "M", "n"),
-        (0x1D5AE, "M", "o"),
-        (0x1D5AF, "M", "p"),
-        (0x1D5B0, "M", "q"),
-        (0x1D5B1, "M", "r"),
-        (0x1D5B2, "M", "s"),
-        (0x1D5B3, "M", "t"),
-        (0x1D5B4, "M", "u"),
-        (0x1D5B5, "M", "v"),
-        (0x1D5B6, "M", "w"),
-        (0x1D5B7, "M", "x"),
-        (0x1D5B8, "M", "y"),
-        (0x1D5B9, "M", "z"),
-        (0x1D5BA, "M", "a"),
-        (0x1D5BB, "M", "b"),
-        (0x1D5BC, "M", "c"),
-        (0x1D5BD, "M", "d"),
-        (0x1D5BE, "M", "e"),
-        (0x1D5BF, "M", "f"),
-        (0x1D5C0, "M", "g"),
-        (0x1D5C1, "M", "h"),
-        (0x1D5C2, "M", "i"),
-        (0x1D5C3, "M", "j"),
-        (0x1D5C4, "M", "k"),
-        (0x1D5C5, "M", "l"),
-        (0x1D5C6, "M", "m"),
-        (0x1D5C7, "M", "n"),
-        (0x1D5C8, "M", "o"),
-        (0x1D5C9, "M", "p"),
-        (0x1D5CA, "M", "q"),
-        (0x1D5CB, "M", "r"),
-        (0x1D5CC, "M", "s"),
-        (0x1D5CD, "M", "t"),
-        (0x1D5CE, "M", "u"),
-        (0x1D5CF, "M", "v"),
-        (0x1D5D0, "M", "w"),
-        (0x1D5D1, "M", "x"),
-        (0x1D5D2, "M", "y"),
-        (0x1D5D3, "M", "z"),
-        (0x1D5D4, "M", "a"),
-        (0x1D5D5, "M", "b"),
-        (0x1D5D6, "M", "c"),
-        (0x1D5D7, "M", "d"),
-        (0x1D5D8, "M", "e"),
-        (0x1D5D9, "M", "f"),
-        (0x1D5DA, "M", "g"),
-        (0x1D5DB, "M", "h"),
-        (0x1D5DC, "M", "i"),
-        (0x1D5DD, "M", "j"),
-        (0x1D5DE, "M", "k"),
-        (0x1D5DF, "M", "l"),
-        (0x1D5E0, "M", "m"),
-        (0x1D5E1, "M", "n"),
-        (0x1D5E2, "M", "o"),
-        (0x1D5E3, "M", "p"),
-        (0x1D5E4, "M", "q"),
-        (0x1D5E5, "M", "r"),
-        (0x1D5E6, "M", "s"),
-        (0x1D5E7, "M", "t"),
-    ]
-
-
-def _seg_64():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D5E8, "M", "u"),
-        (0x1D5E9, "M", "v"),
-        (0x1D5EA, "M", "w"),
-        (0x1D5EB, "M", "x"),
-        (0x1D5EC, "M", "y"),
-        (0x1D5ED, "M", "z"),
-        (0x1D5EE, "M", "a"),
-        (0x1D5EF, "M", "b"),
-        (0x1D5F0, "M", "c"),
-        (0x1D5F1, "M", "d"),
-        (0x1D5F2, "M", "e"),
-        (0x1D5F3, "M", "f"),
-        (0x1D5F4, "M", "g"),
-        (0x1D5F5, "M", "h"),
-        (0x1D5F6, "M", "i"),
-        (0x1D5F7, "M", "j"),
-        (0x1D5F8, "M", "k"),
-        (0x1D5F9, "M", "l"),
-        (0x1D5FA, "M", "m"),
-        (0x1D5FB, "M", "n"),
-        (0x1D5FC, "M", "o"),
-        (0x1D5FD, "M", "p"),
-        (0x1D5FE, "M", "q"),
-        (0x1D5FF, "M", "r"),
-        (0x1D600, "M", "s"),
-        (0x1D601, "M", "t"),
-        (0x1D602, "M", "u"),
-        (0x1D603, "M", "v"),
-        (0x1D604, "M", "w"),
-        (0x1D605, "M", "x"),
-        (0x1D606, "M", "y"),
-        (0x1D607, "M", "z"),
-        (0x1D608, "M", "a"),
-        (0x1D609, "M", "b"),
-        (0x1D60A, "M", "c"),
-        (0x1D60B, "M", "d"),
-        (0x1D60C, "M", "e"),
-        (0x1D60D, "M", "f"),
-        (0x1D60E, "M", "g"),
-        (0x1D60F, "M", "h"),
-        (0x1D610, "M", "i"),
-        (0x1D611, "M", "j"),
-        (0x1D612, "M", "k"),
-        (0x1D613, "M", "l"),
-        (0x1D614, "M", "m"),
-        (0x1D615, "M", "n"),
-        (0x1D616, "M", "o"),
-        (0x1D617, "M", "p"),
-        (0x1D618, "M", "q"),
-        (0x1D619, "M", "r"),
-        (0x1D61A, "M", "s"),
-        (0x1D61B, "M", "t"),
-        (0x1D61C, "M", "u"),
-        (0x1D61D, "M", "v"),
-        (0x1D61E, "M", "w"),
-        (0x1D61F, "M", "x"),
-        (0x1D620, "M", "y"),
-        (0x1D621, "M", "z"),
-        (0x1D622, "M", "a"),
-        (0x1D623, "M", "b"),
-        (0x1D624, "M", "c"),
-        (0x1D625, "M", "d"),
-        (0x1D626, "M", "e"),
-        (0x1D627, "M", "f"),
-        (0x1D628, "M", "g"),
-        (0x1D629, "M", "h"),
-        (0x1D62A, "M", "i"),
-        (0x1D62B, "M", "j"),
-        (0x1D62C, "M", "k"),
-        (0x1D62D, "M", "l"),
-        (0x1D62E, "M", "m"),
-        (0x1D62F, "M", "n"),
-        (0x1D630, "M", "o"),
-        (0x1D631, "M", "p"),
-        (0x1D632, "M", "q"),
-        (0x1D633, "M", "r"),
-        (0x1D634, "M", "s"),
-        (0x1D635, "M", "t"),
-        (0x1D636, "M", "u"),
-        (0x1D637, "M", "v"),
-        (0x1D638, "M", "w"),
-        (0x1D639, "M", "x"),
-        (0x1D63A, "M", "y"),
-        (0x1D63B, "M", "z"),
-        (0x1D63C, "M", "a"),
-        (0x1D63D, "M", "b"),
-        (0x1D63E, "M", "c"),
-        (0x1D63F, "M", "d"),
-        (0x1D640, "M", "e"),
-        (0x1D641, "M", "f"),
-        (0x1D642, "M", "g"),
-        (0x1D643, "M", "h"),
-        (0x1D644, "M", "i"),
-        (0x1D645, "M", "j"),
-        (0x1D646, "M", "k"),
-        (0x1D647, "M", "l"),
-        (0x1D648, "M", "m"),
-        (0x1D649, "M", "n"),
-        (0x1D64A, "M", "o"),
-        (0x1D64B, "M", "p"),
-    ]
-
-
-def _seg_65():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D64C, "M", "q"),
-        (0x1D64D, "M", "r"),
-        (0x1D64E, "M", "s"),
-        (0x1D64F, "M", "t"),
-        (0x1D650, "M", "u"),
-        (0x1D651, "M", "v"),
-        (0x1D652, "M", "w"),
-        (0x1D653, "M", "x"),
-        (0x1D654, "M", "y"),
-        (0x1D655, "M", "z"),
-        (0x1D656, "M", "a"),
-        (0x1D657, "M", "b"),
-        (0x1D658, "M", "c"),
-        (0x1D659, "M", "d"),
-        (0x1D65A, "M", "e"),
-        (0x1D65B, "M", "f"),
-        (0x1D65C, "M", "g"),
-        (0x1D65D, "M", "h"),
-        (0x1D65E, "M", "i"),
-        (0x1D65F, "M", "j"),
-        (0x1D660, "M", "k"),
-        (0x1D661, "M", "l"),
-        (0x1D662, "M", "m"),
-        (0x1D663, "M", "n"),
-        (0x1D664, "M", "o"),
-        (0x1D665, "M", "p"),
-        (0x1D666, "M", "q"),
-        (0x1D667, "M", "r"),
-        (0x1D668, "M", "s"),
-        (0x1D669, "M", "t"),
-        (0x1D66A, "M", "u"),
-        (0x1D66B, "M", "v"),
-        (0x1D66C, "M", "w"),
-        (0x1D66D, "M", "x"),
-        (0x1D66E, "M", "y"),
-        (0x1D66F, "M", "z"),
-        (0x1D670, "M", "a"),
-        (0x1D671, "M", "b"),
-        (0x1D672, "M", "c"),
-        (0x1D673, "M", "d"),
-        (0x1D674, "M", "e"),
-        (0x1D675, "M", "f"),
-        (0x1D676, "M", "g"),
-        (0x1D677, "M", "h"),
-        (0x1D678, "M", "i"),
-        (0x1D679, "M", "j"),
-        (0x1D67A, "M", "k"),
-        (0x1D67B, "M", "l"),
-        (0x1D67C, "M", "m"),
-        (0x1D67D, "M", "n"),
-        (0x1D67E, "M", "o"),
-        (0x1D67F, "M", "p"),
-        (0x1D680, "M", "q"),
-        (0x1D681, "M", "r"),
-        (0x1D682, "M", "s"),
-        (0x1D683, "M", "t"),
-        (0x1D684, "M", "u"),
-        (0x1D685, "M", "v"),
-        (0x1D686, "M", "w"),
-        (0x1D687, "M", "x"),
-        (0x1D688, "M", "y"),
-        (0x1D689, "M", "z"),
-        (0x1D68A, "M", "a"),
-        (0x1D68B, "M", "b"),
-        (0x1D68C, "M", "c"),
-        (0x1D68D, "M", "d"),
-        (0x1D68E, "M", "e"),
-        (0x1D68F, "M", "f"),
-        (0x1D690, "M", "g"),
-        (0x1D691, "M", "h"),
-        (0x1D692, "M", "i"),
-        (0x1D693, "M", "j"),
-        (0x1D694, "M", "k"),
-        (0x1D695, "M", "l"),
-        (0x1D696, "M", "m"),
-        (0x1D697, "M", "n"),
-        (0x1D698, "M", "o"),
-        (0x1D699, "M", "p"),
-        (0x1D69A, "M", "q"),
-        (0x1D69B, "M", "r"),
-        (0x1D69C, "M", "s"),
-        (0x1D69D, "M", "t"),
-        (0x1D69E, "M", "u"),
-        (0x1D69F, "M", "v"),
-        (0x1D6A0, "M", "w"),
-        (0x1D6A1, "M", "x"),
-        (0x1D6A2, "M", "y"),
-        (0x1D6A3, "M", "z"),
-        (0x1D6A4, "M", "ı"),
-        (0x1D6A5, "M", "ȷ"),
-        (0x1D6A6, "X"),
-        (0x1D6A8, "M", "α"),
-        (0x1D6A9, "M", "β"),
-        (0x1D6AA, "M", "γ"),
-        (0x1D6AB, "M", "δ"),
-        (0x1D6AC, "M", "ε"),
-        (0x1D6AD, "M", "ζ"),
-        (0x1D6AE, "M", "η"),
-        (0x1D6AF, "M", "θ"),
-        (0x1D6B0, "M", "ι"),
-    ]
-
-
-def _seg_66():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D6B1, "M", "κ"),
-        (0x1D6B2, "M", "λ"),
-        (0x1D6B3, "M", "μ"),
-        (0x1D6B4, "M", "ν"),
-        (0x1D6B5, "M", "ξ"),
-        (0x1D6B6, "M", "ο"),
-        (0x1D6B7, "M", "π"),
-        (0x1D6B8, "M", "ρ"),
-        (0x1D6B9, "M", "θ"),
-        (0x1D6BA, "M", "σ"),
-        (0x1D6BB, "M", "τ"),
-        (0x1D6BC, "M", "υ"),
-        (0x1D6BD, "M", "φ"),
-        (0x1D6BE, "M", "χ"),
-        (0x1D6BF, "M", "ψ"),
-        (0x1D6C0, "M", "ω"),
-        (0x1D6C1, "M", "∇"),
-        (0x1D6C2, "M", "α"),
-        (0x1D6C3, "M", "β"),
-        (0x1D6C4, "M", "γ"),
-        (0x1D6C5, "M", "δ"),
-        (0x1D6C6, "M", "ε"),
-        (0x1D6C7, "M", "ζ"),
-        (0x1D6C8, "M", "η"),
-        (0x1D6C9, "M", "θ"),
-        (0x1D6CA, "M", "ι"),
-        (0x1D6CB, "M", "κ"),
-        (0x1D6CC, "M", "λ"),
-        (0x1D6CD, "M", "μ"),
-        (0x1D6CE, "M", "ν"),
-        (0x1D6CF, "M", "ξ"),
-        (0x1D6D0, "M", "ο"),
-        (0x1D6D1, "M", "π"),
-        (0x1D6D2, "M", "ρ"),
-        (0x1D6D3, "M", "σ"),
-        (0x1D6D5, "M", "τ"),
-        (0x1D6D6, "M", "υ"),
-        (0x1D6D7, "M", "φ"),
-        (0x1D6D8, "M", "χ"),
-        (0x1D6D9, "M", "ψ"),
-        (0x1D6DA, "M", "ω"),
-        (0x1D6DB, "M", "∂"),
-        (0x1D6DC, "M", "ε"),
-        (0x1D6DD, "M", "θ"),
-        (0x1D6DE, "M", "κ"),
-        (0x1D6DF, "M", "φ"),
-        (0x1D6E0, "M", "ρ"),
-        (0x1D6E1, "M", "π"),
-        (0x1D6E2, "M", "α"),
-        (0x1D6E3, "M", "β"),
-        (0x1D6E4, "M", "γ"),
-        (0x1D6E5, "M", "δ"),
-        (0x1D6E6, "M", "ε"),
-        (0x1D6E7, "M", "ζ"),
-        (0x1D6E8, "M", "η"),
-        (0x1D6E9, "M", "θ"),
-        (0x1D6EA, "M", "ι"),
-        (0x1D6EB, "M", "κ"),
-        (0x1D6EC, "M", "λ"),
-        (0x1D6ED, "M", "μ"),
-        (0x1D6EE, "M", "ν"),
-        (0x1D6EF, "M", "ξ"),
-        (0x1D6F0, "M", "ο"),
-        (0x1D6F1, "M", "π"),
-        (0x1D6F2, "M", "ρ"),
-        (0x1D6F3, "M", "θ"),
-        (0x1D6F4, "M", "σ"),
-        (0x1D6F5, "M", "τ"),
-        (0x1D6F6, "M", "υ"),
-        (0x1D6F7, "M", "φ"),
-        (0x1D6F8, "M", "χ"),
-        (0x1D6F9, "M", "ψ"),
-        (0x1D6FA, "M", "ω"),
-        (0x1D6FB, "M", "∇"),
-        (0x1D6FC, "M", "α"),
-        (0x1D6FD, "M", "β"),
-        (0x1D6FE, "M", "γ"),
-        (0x1D6FF, "M", "δ"),
-        (0x1D700, "M", "ε"),
-        (0x1D701, "M", "ζ"),
-        (0x1D702, "M", "η"),
-        (0x1D703, "M", "θ"),
-        (0x1D704, "M", "ι"),
-        (0x1D705, "M", "κ"),
-        (0x1D706, "M", "λ"),
-        (0x1D707, "M", "μ"),
-        (0x1D708, "M", "ν"),
-        (0x1D709, "M", "ξ"),
-        (0x1D70A, "M", "ο"),
-        (0x1D70B, "M", "π"),
-        (0x1D70C, "M", "ρ"),
-        (0x1D70D, "M", "σ"),
-        (0x1D70F, "M", "τ"),
-        (0x1D710, "M", "υ"),
-        (0x1D711, "M", "φ"),
-        (0x1D712, "M", "χ"),
-        (0x1D713, "M", "ψ"),
-        (0x1D714, "M", "ω"),
-        (0x1D715, "M", "∂"),
-        (0x1D716, "M", "ε"),
-    ]
-
-
-def _seg_67():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D717, "M", "θ"),
-        (0x1D718, "M", "κ"),
-        (0x1D719, "M", "φ"),
-        (0x1D71A, "M", "ρ"),
-        (0x1D71B, "M", "π"),
-        (0x1D71C, "M", "α"),
-        (0x1D71D, "M", "β"),
-        (0x1D71E, "M", "γ"),
-        (0x1D71F, "M", "δ"),
-        (0x1D720, "M", "ε"),
-        (0x1D721, "M", "ζ"),
-        (0x1D722, "M", "η"),
-        (0x1D723, "M", "θ"),
-        (0x1D724, "M", "ι"),
-        (0x1D725, "M", "κ"),
-        (0x1D726, "M", "λ"),
-        (0x1D727, "M", "μ"),
-        (0x1D728, "M", "ν"),
-        (0x1D729, "M", "ξ"),
-        (0x1D72A, "M", "ο"),
-        (0x1D72B, "M", "π"),
-        (0x1D72C, "M", "ρ"),
-        (0x1D72D, "M", "θ"),
-        (0x1D72E, "M", "σ"),
-        (0x1D72F, "M", "τ"),
-        (0x1D730, "M", "υ"),
-        (0x1D731, "M", "φ"),
-        (0x1D732, "M", "χ"),
-        (0x1D733, "M", "ψ"),
-        (0x1D734, "M", "ω"),
-        (0x1D735, "M", "∇"),
-        (0x1D736, "M", "α"),
-        (0x1D737, "M", "β"),
-        (0x1D738, "M", "γ"),
-        (0x1D739, "M", "δ"),
-        (0x1D73A, "M", "ε"),
-        (0x1D73B, "M", "ζ"),
-        (0x1D73C, "M", "η"),
-        (0x1D73D, "M", "θ"),
-        (0x1D73E, "M", "ι"),
-        (0x1D73F, "M", "κ"),
-        (0x1D740, "M", "λ"),
-        (0x1D741, "M", "μ"),
-        (0x1D742, "M", "ν"),
-        (0x1D743, "M", "ξ"),
-        (0x1D744, "M", "ο"),
-        (0x1D745, "M", "π"),
-        (0x1D746, "M", "ρ"),
-        (0x1D747, "M", "σ"),
-        (0x1D749, "M", "τ"),
-        (0x1D74A, "M", "υ"),
-        (0x1D74B, "M", "φ"),
-        (0x1D74C, "M", "χ"),
-        (0x1D74D, "M", "ψ"),
-        (0x1D74E, "M", "ω"),
-        (0x1D74F, "M", "∂"),
-        (0x1D750, "M", "ε"),
-        (0x1D751, "M", "θ"),
-        (0x1D752, "M", "κ"),
-        (0x1D753, "M", "φ"),
-        (0x1D754, "M", "ρ"),
-        (0x1D755, "M", "π"),
-        (0x1D756, "M", "α"),
-        (0x1D757, "M", "β"),
-        (0x1D758, "M", "γ"),
-        (0x1D759, "M", "δ"),
-        (0x1D75A, "M", "ε"),
-        (0x1D75B, "M", "ζ"),
-        (0x1D75C, "M", "η"),
-        (0x1D75D, "M", "θ"),
-        (0x1D75E, "M", "ι"),
-        (0x1D75F, "M", "κ"),
-        (0x1D760, "M", "λ"),
-        (0x1D761, "M", "μ"),
-        (0x1D762, "M", "ν"),
-        (0x1D763, "M", "ξ"),
-        (0x1D764, "M", "ο"),
-        (0x1D765, "M", "π"),
-        (0x1D766, "M", "ρ"),
-        (0x1D767, "M", "θ"),
-        (0x1D768, "M", "σ"),
-        (0x1D769, "M", "τ"),
-        (0x1D76A, "M", "υ"),
-        (0x1D76B, "M", "φ"),
-        (0x1D76C, "M", "χ"),
-        (0x1D76D, "M", "ψ"),
-        (0x1D76E, "M", "ω"),
-        (0x1D76F, "M", "∇"),
-        (0x1D770, "M", "α"),
-        (0x1D771, "M", "β"),
-        (0x1D772, "M", "γ"),
-        (0x1D773, "M", "δ"),
-        (0x1D774, "M", "ε"),
-        (0x1D775, "M", "ζ"),
-        (0x1D776, "M", "η"),
-        (0x1D777, "M", "θ"),
-        (0x1D778, "M", "ι"),
-        (0x1D779, "M", "κ"),
-        (0x1D77A, "M", "λ"),
-        (0x1D77B, "M", "μ"),
-    ]
-
-
-def _seg_68():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D77C, "M", "ν"),
-        (0x1D77D, "M", "ξ"),
-        (0x1D77E, "M", "ο"),
-        (0x1D77F, "M", "π"),
-        (0x1D780, "M", "ρ"),
-        (0x1D781, "M", "σ"),
-        (0x1D783, "M", "τ"),
-        (0x1D784, "M", "υ"),
-        (0x1D785, "M", "φ"),
-        (0x1D786, "M", "χ"),
-        (0x1D787, "M", "ψ"),
-        (0x1D788, "M", "ω"),
-        (0x1D789, "M", "∂"),
-        (0x1D78A, "M", "ε"),
-        (0x1D78B, "M", "θ"),
-        (0x1D78C, "M", "κ"),
-        (0x1D78D, "M", "φ"),
-        (0x1D78E, "M", "ρ"),
-        (0x1D78F, "M", "π"),
-        (0x1D790, "M", "α"),
-        (0x1D791, "M", "β"),
-        (0x1D792, "M", "γ"),
-        (0x1D793, "M", "δ"),
-        (0x1D794, "M", "ε"),
-        (0x1D795, "M", "ζ"),
-        (0x1D796, "M", "η"),
-        (0x1D797, "M", "θ"),
-        (0x1D798, "M", "ι"),
-        (0x1D799, "M", "κ"),
-        (0x1D79A, "M", "λ"),
-        (0x1D79B, "M", "μ"),
-        (0x1D79C, "M", "ν"),
-        (0x1D79D, "M", "ξ"),
-        (0x1D79E, "M", "ο"),
-        (0x1D79F, "M", "π"),
-        (0x1D7A0, "M", "ρ"),
-        (0x1D7A1, "M", "θ"),
-        (0x1D7A2, "M", "σ"),
-        (0x1D7A3, "M", "τ"),
-        (0x1D7A4, "M", "υ"),
-        (0x1D7A5, "M", "φ"),
-        (0x1D7A6, "M", "χ"),
-        (0x1D7A7, "M", "ψ"),
-        (0x1D7A8, "M", "ω"),
-        (0x1D7A9, "M", "∇"),
-        (0x1D7AA, "M", "α"),
-        (0x1D7AB, "M", "β"),
-        (0x1D7AC, "M", "γ"),
-        (0x1D7AD, "M", "δ"),
-        (0x1D7AE, "M", "ε"),
-        (0x1D7AF, "M", "ζ"),
-        (0x1D7B0, "M", "η"),
-        (0x1D7B1, "M", "θ"),
-        (0x1D7B2, "M", "ι"),
-        (0x1D7B3, "M", "κ"),
-        (0x1D7B4, "M", "λ"),
-        (0x1D7B5, "M", "μ"),
-        (0x1D7B6, "M", "ν"),
-        (0x1D7B7, "M", "ξ"),
-        (0x1D7B8, "M", "ο"),
-        (0x1D7B9, "M", "π"),
-        (0x1D7BA, "M", "ρ"),
-        (0x1D7BB, "M", "σ"),
-        (0x1D7BD, "M", "τ"),
-        (0x1D7BE, "M", "υ"),
-        (0x1D7BF, "M", "φ"),
-        (0x1D7C0, "M", "χ"),
-        (0x1D7C1, "M", "ψ"),
-        (0x1D7C2, "M", "ω"),
-        (0x1D7C3, "M", "∂"),
-        (0x1D7C4, "M", "ε"),
-        (0x1D7C5, "M", "θ"),
-        (0x1D7C6, "M", "κ"),
-        (0x1D7C7, "M", "φ"),
-        (0x1D7C8, "M", "ρ"),
-        (0x1D7C9, "M", "π"),
-        (0x1D7CA, "M", "ϝ"),
-        (0x1D7CC, "X"),
-        (0x1D7CE, "M", "0"),
-        (0x1D7CF, "M", "1"),
-        (0x1D7D0, "M", "2"),
-        (0x1D7D1, "M", "3"),
-        (0x1D7D2, "M", "4"),
-        (0x1D7D3, "M", "5"),
-        (0x1D7D4, "M", "6"),
-        (0x1D7D5, "M", "7"),
-        (0x1D7D6, "M", "8"),
-        (0x1D7D7, "M", "9"),
-        (0x1D7D8, "M", "0"),
-        (0x1D7D9, "M", "1"),
-        (0x1D7DA, "M", "2"),
-        (0x1D7DB, "M", "3"),
-        (0x1D7DC, "M", "4"),
-        (0x1D7DD, "M", "5"),
-        (0x1D7DE, "M", "6"),
-        (0x1D7DF, "M", "7"),
-        (0x1D7E0, "M", "8"),
-        (0x1D7E1, "M", "9"),
-        (0x1D7E2, "M", "0"),
-        (0x1D7E3, "M", "1"),
-    ]
-
-
-def _seg_69():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1D7E4, "M", "2"),
-        (0x1D7E5, "M", "3"),
-        (0x1D7E6, "M", "4"),
-        (0x1D7E7, "M", "5"),
-        (0x1D7E8, "M", "6"),
-        (0x1D7E9, "M", "7"),
-        (0x1D7EA, "M", "8"),
-        (0x1D7EB, "M", "9"),
-        (0x1D7EC, "M", "0"),
-        (0x1D7ED, "M", "1"),
-        (0x1D7EE, "M", "2"),
-        (0x1D7EF, "M", "3"),
-        (0x1D7F0, "M", "4"),
-        (0x1D7F1, "M", "5"),
-        (0x1D7F2, "M", "6"),
-        (0x1D7F3, "M", "7"),
-        (0x1D7F4, "M", "8"),
-        (0x1D7F5, "M", "9"),
-        (0x1D7F6, "M", "0"),
-        (0x1D7F7, "M", "1"),
-        (0x1D7F8, "M", "2"),
-        (0x1D7F9, "M", "3"),
-        (0x1D7FA, "M", "4"),
-        (0x1D7FB, "M", "5"),
-        (0x1D7FC, "M", "6"),
-        (0x1D7FD, "M", "7"),
-        (0x1D7FE, "M", "8"),
-        (0x1D7FF, "M", "9"),
-        (0x1D800, "V"),
-        (0x1DA8C, "X"),
-        (0x1DA9B, "V"),
-        (0x1DAA0, "X"),
-        (0x1DAA1, "V"),
-        (0x1DAB0, "X"),
-        (0x1E000, "V"),
-        (0x1E007, "X"),
-        (0x1E008, "V"),
-        (0x1E019, "X"),
-        (0x1E01B, "V"),
-        (0x1E022, "X"),
-        (0x1E023, "V"),
-        (0x1E025, "X"),
-        (0x1E026, "V"),
-        (0x1E02B, "X"),
-        (0x1E100, "V"),
-        (0x1E12D, "X"),
-        (0x1E130, "V"),
-        (0x1E13E, "X"),
-        (0x1E140, "V"),
-        (0x1E14A, "X"),
-        (0x1E14E, "V"),
-        (0x1E150, "X"),
-        (0x1E2C0, "V"),
-        (0x1E2FA, "X"),
-        (0x1E2FF, "V"),
-        (0x1E300, "X"),
-        (0x1E800, "V"),
-        (0x1E8C5, "X"),
-        (0x1E8C7, "V"),
-        (0x1E8D7, "X"),
-        (0x1E900, "M", "𞤢"),
-        (0x1E901, "M", "𞤣"),
-        (0x1E902, "M", "𞤤"),
-        (0x1E903, "M", "𞤥"),
-        (0x1E904, "M", "𞤦"),
-        (0x1E905, "M", "𞤧"),
-        (0x1E906, "M", "𞤨"),
-        (0x1E907, "M", "𞤩"),
-        (0x1E908, "M", "𞤪"),
-        (0x1E909, "M", "𞤫"),
-        (0x1E90A, "M", "𞤬"),
-        (0x1E90B, "M", "𞤭"),
-        (0x1E90C, "M", "𞤮"),
-        (0x1E90D, "M", "𞤯"),
-        (0x1E90E, "M", "𞤰"),
-        (0x1E90F, "M", "𞤱"),
-        (0x1E910, "M", "𞤲"),
-        (0x1E911, "M", "𞤳"),
-        (0x1E912, "M", "𞤴"),
-        (0x1E913, "M", "𞤵"),
-        (0x1E914, "M", "𞤶"),
-        (0x1E915, "M", "𞤷"),
-        (0x1E916, "M", "𞤸"),
-        (0x1E917, "M", "𞤹"),
-        (0x1E918, "M", "𞤺"),
-        (0x1E919, "M", "𞤻"),
-        (0x1E91A, "M", "𞤼"),
-        (0x1E91B, "M", "𞤽"),
-        (0x1E91C, "M", "𞤾"),
-        (0x1E91D, "M", "𞤿"),
-        (0x1E91E, "M", "𞥀"),
-        (0x1E91F, "M", "𞥁"),
-        (0x1E920, "M", "𞥂"),
-        (0x1E921, "M", "𞥃"),
-        (0x1E922, "V"),
-        (0x1E94C, "X"),
-        (0x1E950, "V"),
-        (0x1E95A, "X"),
-        (0x1E95E, "V"),
-        (0x1E960, "X"),
-    ]
-
-
-def _seg_70():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1EC71, "V"),
-        (0x1ECB5, "X"),
-        (0x1ED01, "V"),
-        (0x1ED3E, "X"),
-        (0x1EE00, "M", "ا"),
-        (0x1EE01, "M", "ب"),
-        (0x1EE02, "M", "ج"),
-        (0x1EE03, "M", "د"),
-        (0x1EE04, "X"),
-        (0x1EE05, "M", "و"),
-        (0x1EE06, "M", "ز"),
-        (0x1EE07, "M", "ح"),
-        (0x1EE08, "M", "ط"),
-        (0x1EE09, "M", "ي"),
-        (0x1EE0A, "M", "ك"),
-        (0x1EE0B, "M", "ل"),
-        (0x1EE0C, "M", "م"),
-        (0x1EE0D, "M", "ن"),
-        (0x1EE0E, "M", "س"),
-        (0x1EE0F, "M", "ع"),
-        (0x1EE10, "M", "ف"),
-        (0x1EE11, "M", "ص"),
-        (0x1EE12, "M", "ق"),
-        (0x1EE13, "M", "ر"),
-        (0x1EE14, "M", "ش"),
-        (0x1EE15, "M", "ت"),
-        (0x1EE16, "M", "ث"),
-        (0x1EE17, "M", "خ"),
-        (0x1EE18, "M", "ذ"),
-        (0x1EE19, "M", "ض"),
-        (0x1EE1A, "M", "ظ"),
-        (0x1EE1B, "M", "غ"),
-        (0x1EE1C, "M", "ٮ"),
-        (0x1EE1D, "M", "ں"),
-        (0x1EE1E, "M", "ڡ"),
-        (0x1EE1F, "M", "ٯ"),
-        (0x1EE20, "X"),
-        (0x1EE21, "M", "ب"),
-        (0x1EE22, "M", "ج"),
-        (0x1EE23, "X"),
-        (0x1EE24, "M", "ه"),
-        (0x1EE25, "X"),
-        (0x1EE27, "M", "ح"),
-        (0x1EE28, "X"),
-        (0x1EE29, "M", "ي"),
-        (0x1EE2A, "M", "ك"),
-        (0x1EE2B, "M", "ل"),
-        (0x1EE2C, "M", "م"),
-        (0x1EE2D, "M", "ن"),
-        (0x1EE2E, "M", "س"),
-        (0x1EE2F, "M", "ع"),
-        (0x1EE30, "M", "ف"),
-        (0x1EE31, "M", "ص"),
-        (0x1EE32, "M", "ق"),
-        (0x1EE33, "X"),
-        (0x1EE34, "M", "ش"),
-        (0x1EE35, "M", "ت"),
-        (0x1EE36, "M", "ث"),
-        (0x1EE37, "M", "خ"),
-        (0x1EE38, "X"),
-        (0x1EE39, "M", "ض"),
-        (0x1EE3A, "X"),
-        (0x1EE3B, "M", "غ"),
-        (0x1EE3C, "X"),
-        (0x1EE42, "M", "ج"),
-        (0x1EE43, "X"),
-        (0x1EE47, "M", "ح"),
-        (0x1EE48, "X"),
-        (0x1EE49, "M", "ي"),
-        (0x1EE4A, "X"),
-        (0x1EE4B, "M", "ل"),
-        (0x1EE4C, "X"),
-        (0x1EE4D, "M", "ن"),
-        (0x1EE4E, "M", "س"),
-        (0x1EE4F, "M", "ع"),
-        (0x1EE50, "X"),
-        (0x1EE51, "M", "ص"),
-        (0x1EE52, "M", "ق"),
-        (0x1EE53, "X"),
-        (0x1EE54, "M", "ش"),
-        (0x1EE55, "X"),
-        (0x1EE57, "M", "خ"),
-        (0x1EE58, "X"),
-        (0x1EE59, "M", "ض"),
-        (0x1EE5A, "X"),
-        (0x1EE5B, "M", "غ"),
-        (0x1EE5C, "X"),
-        (0x1EE5D, "M", "ں"),
-        (0x1EE5E, "X"),
-        (0x1EE5F, "M", "ٯ"),
-        (0x1EE60, "X"),
-        (0x1EE61, "M", "ب"),
-        (0x1EE62, "M", "ج"),
-        (0x1EE63, "X"),
-        (0x1EE64, "M", "ه"),
-        (0x1EE65, "X"),
-        (0x1EE67, "M", "ح"),
-        (0x1EE68, "M", "ط"),
-        (0x1EE69, "M", "ي"),
-        (0x1EE6A, "M", "ك"),
-    ]
-
-
-def _seg_71():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1EE6B, "X"),
-        (0x1EE6C, "M", "م"),
-        (0x1EE6D, "M", "ن"),
-        (0x1EE6E, "M", "س"),
-        (0x1EE6F, "M", "ع"),
-        (0x1EE70, "M", "ف"),
-        (0x1EE71, "M", "ص"),
-        (0x1EE72, "M", "ق"),
-        (0x1EE73, "X"),
-        (0x1EE74, "M", "ش"),
-        (0x1EE75, "M", "ت"),
-        (0x1EE76, "M", "ث"),
-        (0x1EE77, "M", "خ"),
-        (0x1EE78, "X"),
-        (0x1EE79, "M", "ض"),
-        (0x1EE7A, "M", "ظ"),
-        (0x1EE7B, "M", "غ"),
-        (0x1EE7C, "M", "ٮ"),
-        (0x1EE7D, "X"),
-        (0x1EE7E, "M", "ڡ"),
-        (0x1EE7F, "X"),
-        (0x1EE80, "M", "ا"),
-        (0x1EE81, "M", "ب"),
-        (0x1EE82, "M", "ج"),
-        (0x1EE83, "M", "د"),
-        (0x1EE84, "M", "ه"),
-        (0x1EE85, "M", "و"),
-        (0x1EE86, "M", "ز"),
-        (0x1EE87, "M", "ح"),
-        (0x1EE88, "M", "ط"),
-        (0x1EE89, "M", "ي"),
-        (0x1EE8A, "X"),
-        (0x1EE8B, "M", "ل"),
-        (0x1EE8C, "M", "م"),
-        (0x1EE8D, "M", "ن"),
-        (0x1EE8E, "M", "س"),
-        (0x1EE8F, "M", "ع"),
-        (0x1EE90, "M", "ف"),
-        (0x1EE91, "M", "ص"),
-        (0x1EE92, "M", "ق"),
-        (0x1EE93, "M", "ر"),
-        (0x1EE94, "M", "ش"),
-        (0x1EE95, "M", "ت"),
-        (0x1EE96, "M", "ث"),
-        (0x1EE97, "M", "خ"),
-        (0x1EE98, "M", "ذ"),
-        (0x1EE99, "M", "ض"),
-        (0x1EE9A, "M", "ظ"),
-        (0x1EE9B, "M", "غ"),
-        (0x1EE9C, "X"),
-        (0x1EEA1, "M", "ب"),
-        (0x1EEA2, "M", "ج"),
-        (0x1EEA3, "M", "د"),
-        (0x1EEA4, "X"),
-        (0x1EEA5, "M", "و"),
-        (0x1EEA6, "M", "ز"),
-        (0x1EEA7, "M", "ح"),
-        (0x1EEA8, "M", "ط"),
-        (0x1EEA9, "M", "ي"),
-        (0x1EEAA, "X"),
-        (0x1EEAB, "M", "ل"),
-        (0x1EEAC, "M", "م"),
-        (0x1EEAD, "M", "ن"),
-        (0x1EEAE, "M", "س"),
-        (0x1EEAF, "M", "ع"),
-        (0x1EEB0, "M", "ف"),
-        (0x1EEB1, "M", "ص"),
-        (0x1EEB2, "M", "ق"),
-        (0x1EEB3, "M", "ر"),
-        (0x1EEB4, "M", "ش"),
-        (0x1EEB5, "M", "ت"),
-        (0x1EEB6, "M", "ث"),
-        (0x1EEB7, "M", "خ"),
-        (0x1EEB8, "M", "ذ"),
-        (0x1EEB9, "M", "ض"),
-        (0x1EEBA, "M", "ظ"),
-        (0x1EEBB, "M", "غ"),
-        (0x1EEBC, "X"),
-        (0x1EEF0, "V"),
-        (0x1EEF2, "X"),
-        (0x1F000, "V"),
-        (0x1F02C, "X"),
-        (0x1F030, "V"),
-        (0x1F094, "X"),
-        (0x1F0A0, "V"),
-        (0x1F0AF, "X"),
-        (0x1F0B1, "V"),
-        (0x1F0C0, "X"),
-        (0x1F0C1, "V"),
-        (0x1F0D0, "X"),
-        (0x1F0D1, "V"),
-        (0x1F0F6, "X"),
-        (0x1F101, "3", "0,"),
-        (0x1F102, "3", "1,"),
-        (0x1F103, "3", "2,"),
-        (0x1F104, "3", "3,"),
-        (0x1F105, "3", "4,"),
-        (0x1F106, "3", "5,"),
-        (0x1F107, "3", "6,"),
-        (0x1F108, "3", "7,"),
-    ]
-
-
-def _seg_72():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1F109, "3", "8,"),
-        (0x1F10A, "3", "9,"),
-        (0x1F10B, "V"),
-        (0x1F110, "3", "(a)"),
-        (0x1F111, "3", "(b)"),
-        (0x1F112, "3", "(c)"),
-        (0x1F113, "3", "(d)"),
-        (0x1F114, "3", "(e)"),
-        (0x1F115, "3", "(f)"),
-        (0x1F116, "3", "(g)"),
-        (0x1F117, "3", "(h)"),
-        (0x1F118, "3", "(i)"),
-        (0x1F119, "3", "(j)"),
-        (0x1F11A, "3", "(k)"),
-        (0x1F11B, "3", "(l)"),
-        (0x1F11C, "3", "(m)"),
-        (0x1F11D, "3", "(n)"),
-        (0x1F11E, "3", "(o)"),
-        (0x1F11F, "3", "(p)"),
-        (0x1F120, "3", "(q)"),
-        (0x1F121, "3", "(r)"),
-        (0x1F122, "3", "(s)"),
-        (0x1F123, "3", "(t)"),
-        (0x1F124, "3", "(u)"),
-        (0x1F125, "3", "(v)"),
-        (0x1F126, "3", "(w)"),
-        (0x1F127, "3", "(x)"),
-        (0x1F128, "3", "(y)"),
-        (0x1F129, "3", "(z)"),
-        (0x1F12A, "M", "〔s〕"),
-        (0x1F12B, "M", "c"),
-        (0x1F12C, "M", "r"),
-        (0x1F12D, "M", "cd"),
-        (0x1F12E, "M", "wz"),
-        (0x1F12F, "V"),
-        (0x1F130, "M", "a"),
-        (0x1F131, "M", "b"),
-        (0x1F132, "M", "c"),
-        (0x1F133, "M", "d"),
-        (0x1F134, "M", "e"),
-        (0x1F135, "M", "f"),
-        (0x1F136, "M", "g"),
-        (0x1F137, "M", "h"),
-        (0x1F138, "M", "i"),
-        (0x1F139, "M", "j"),
-        (0x1F13A, "M", "k"),
-        (0x1F13B, "M", "l"),
-        (0x1F13C, "M", "m"),
-        (0x1F13D, "M", "n"),
-        (0x1F13E, "M", "o"),
-        (0x1F13F, "M", "p"),
-        (0x1F140, "M", "q"),
-        (0x1F141, "M", "r"),
-        (0x1F142, "M", "s"),
-        (0x1F143, "M", "t"),
-        (0x1F144, "M", "u"),
-        (0x1F145, "M", "v"),
-        (0x1F146, "M", "w"),
-        (0x1F147, "M", "x"),
-        (0x1F148, "M", "y"),
-        (0x1F149, "M", "z"),
-        (0x1F14A, "M", "hv"),
-        (0x1F14B, "M", "mv"),
-        (0x1F14C, "M", "sd"),
-        (0x1F14D, "M", "ss"),
-        (0x1F14E, "M", "ppv"),
-        (0x1F14F, "M", "wc"),
-        (0x1F150, "V"),
-        (0x1F16A, "M", "mc"),
-        (0x1F16B, "M", "md"),
-        (0x1F16C, "M", "mr"),
-        (0x1F16D, "V"),
-        (0x1F190, "M", "dj"),
-        (0x1F191, "V"),
-        (0x1F1AE, "X"),
-        (0x1F1E6, "V"),
-        (0x1F200, "M", "ほか"),
-        (0x1F201, "M", "ココ"),
-        (0x1F202, "M", "サ"),
-        (0x1F203, "X"),
-        (0x1F210, "M", "手"),
-        (0x1F211, "M", "字"),
-        (0x1F212, "M", "双"),
-        (0x1F213, "M", "デ"),
-        (0x1F214, "M", "二"),
-        (0x1F215, "M", "多"),
-        (0x1F216, "M", "解"),
-        (0x1F217, "M", "天"),
-        (0x1F218, "M", "交"),
-        (0x1F219, "M", "映"),
-        (0x1F21A, "M", "無"),
-        (0x1F21B, "M", "料"),
-        (0x1F21C, "M", "前"),
-        (0x1F21D, "M", "後"),
-        (0x1F21E, "M", "再"),
-        (0x1F21F, "M", "新"),
-        (0x1F220, "M", "初"),
-        (0x1F221, "M", "終"),
-        (0x1F222, "M", "生"),
-        (0x1F223, "M", "販"),
-    ]
-
-
-def _seg_73():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1F224, "M", "声"),
-        (0x1F225, "M", "吹"),
-        (0x1F226, "M", "演"),
-        (0x1F227, "M", "投"),
-        (0x1F228, "M", "捕"),
-        (0x1F229, "M", "一"),
-        (0x1F22A, "M", "三"),
-        (0x1F22B, "M", "遊"),
-        (0x1F22C, "M", "左"),
-        (0x1F22D, "M", "中"),
-        (0x1F22E, "M", "右"),
-        (0x1F22F, "M", "指"),
-        (0x1F230, "M", "走"),
-        (0x1F231, "M", "打"),
-        (0x1F232, "M", "禁"),
-        (0x1F233, "M", "空"),
-        (0x1F234, "M", "合"),
-        (0x1F235, "M", "満"),
-        (0x1F236, "M", "有"),
-        (0x1F237, "M", "月"),
-        (0x1F238, "M", "申"),
-        (0x1F239, "M", "割"),
-        (0x1F23A, "M", "営"),
-        (0x1F23B, "M", "配"),
-        (0x1F23C, "X"),
-        (0x1F240, "M", "〔本〕"),
-        (0x1F241, "M", "〔三〕"),
-        (0x1F242, "M", "〔二〕"),
-        (0x1F243, "M", "〔安〕"),
-        (0x1F244, "M", "〔点〕"),
-        (0x1F245, "M", "〔打〕"),
-        (0x1F246, "M", "〔盗〕"),
-        (0x1F247, "M", "〔勝〕"),
-        (0x1F248, "M", "〔敗〕"),
-        (0x1F249, "X"),
-        (0x1F250, "M", "得"),
-        (0x1F251, "M", "可"),
-        (0x1F252, "X"),
-        (0x1F260, "V"),
-        (0x1F266, "X"),
-        (0x1F300, "V"),
-        (0x1F6D8, "X"),
-        (0x1F6E0, "V"),
-        (0x1F6ED, "X"),
-        (0x1F6F0, "V"),
-        (0x1F6FD, "X"),
-        (0x1F700, "V"),
-        (0x1F774, "X"),
-        (0x1F780, "V"),
-        (0x1F7D9, "X"),
-        (0x1F7E0, "V"),
-        (0x1F7EC, "X"),
-        (0x1F800, "V"),
-        (0x1F80C, "X"),
-        (0x1F810, "V"),
-        (0x1F848, "X"),
-        (0x1F850, "V"),
-        (0x1F85A, "X"),
-        (0x1F860, "V"),
-        (0x1F888, "X"),
-        (0x1F890, "V"),
-        (0x1F8AE, "X"),
-        (0x1F8B0, "V"),
-        (0x1F8B2, "X"),
-        (0x1F900, "V"),
-        (0x1F979, "X"),
-        (0x1F97A, "V"),
-        (0x1F9CC, "X"),
-        (0x1F9CD, "V"),
-        (0x1FA54, "X"),
-        (0x1FA60, "V"),
-        (0x1FA6E, "X"),
-        (0x1FA70, "V"),
-        (0x1FA75, "X"),
-        (0x1FA78, "V"),
-        (0x1FA7B, "X"),
-        (0x1FA80, "V"),
-        (0x1FA87, "X"),
-        (0x1FA90, "V"),
-        (0x1FAA9, "X"),
-        (0x1FAB0, "V"),
-        (0x1FAB7, "X"),
-        (0x1FAC0, "V"),
-        (0x1FAC3, "X"),
-        (0x1FAD0, "V"),
-        (0x1FAD7, "X"),
-        (0x1FB00, "V"),
-        (0x1FB93, "X"),
-        (0x1FB94, "V"),
-        (0x1FBCB, "X"),
-        (0x1FBF0, "M", "0"),
-        (0x1FBF1, "M", "1"),
-        (0x1FBF2, "M", "2"),
-        (0x1FBF3, "M", "3"),
-        (0x1FBF4, "M", "4"),
-        (0x1FBF5, "M", "5"),
-        (0x1FBF6, "M", "6"),
-        (0x1FBF7, "M", "7"),
-        (0x1FBF8, "M", "8"),
-        (0x1FBF9, "M", "9"),
-    ]
-
-
-def _seg_74():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x1FBFA, "X"),
-        (0x20000, "V"),
-        (0x2A6DE, "X"),
-        (0x2A700, "V"),
-        (0x2B735, "X"),
-        (0x2B740, "V"),
-        (0x2B81E, "X"),
-        (0x2B820, "V"),
-        (0x2CEA2, "X"),
-        (0x2CEB0, "V"),
-        (0x2EBE1, "X"),
-        (0x2F800, "M", "丽"),
-        (0x2F801, "M", "丸"),
-        (0x2F802, "M", "乁"),
-        (0x2F803, "M", "𠄢"),
-        (0x2F804, "M", "你"),
-        (0x2F805, "M", "侮"),
-        (0x2F806, "M", "侻"),
-        (0x2F807, "M", "倂"),
-        (0x2F808, "M", "偺"),
-        (0x2F809, "M", "備"),
-        (0x2F80A, "M", "僧"),
-        (0x2F80B, "M", "像"),
-        (0x2F80C, "M", "㒞"),
-        (0x2F80D, "M", "𠘺"),
-        (0x2F80E, "M", "免"),
-        (0x2F80F, "M", "兔"),
-        (0x2F810, "M", "兤"),
-        (0x2F811, "M", "具"),
-        (0x2F812, "M", "𠔜"),
-        (0x2F813, "M", "㒹"),
-        (0x2F814, "M", "內"),
-        (0x2F815, "M", "再"),
-        (0x2F816, "M", "𠕋"),
-        (0x2F817, "M", "冗"),
-        (0x2F818, "M", "冤"),
-        (0x2F819, "M", "仌"),
-        (0x2F81A, "M", "冬"),
-        (0x2F81B, "M", "况"),
-        (0x2F81C, "M", "𩇟"),
-        (0x2F81D, "M", "凵"),
-        (0x2F81E, "M", "刃"),
-        (0x2F81F, "M", "㓟"),
-        (0x2F820, "M", "刻"),
-        (0x2F821, "M", "剆"),
-        (0x2F822, "M", "割"),
-        (0x2F823, "M", "剷"),
-        (0x2F824, "M", "㔕"),
-        (0x2F825, "M", "勇"),
-        (0x2F826, "M", "勉"),
-        (0x2F827, "M", "勤"),
-        (0x2F828, "M", "勺"),
-        (0x2F829, "M", "包"),
-        (0x2F82A, "M", "匆"),
-        (0x2F82B, "M", "北"),
-        (0x2F82C, "M", "卉"),
-        (0x2F82D, "M", "卑"),
-        (0x2F82E, "M", "博"),
-        (0x2F82F, "M", "即"),
-        (0x2F830, "M", "卽"),
-        (0x2F831, "M", "卿"),
-        (0x2F834, "M", "𠨬"),
-        (0x2F835, "M", "灰"),
-        (0x2F836, "M", "及"),
-        (0x2F837, "M", "叟"),
-        (0x2F838, "M", "𠭣"),
-        (0x2F839, "M", "叫"),
-        (0x2F83A, "M", "叱"),
-        (0x2F83B, "M", "吆"),
-        (0x2F83C, "M", "咞"),
-        (0x2F83D, "M", "吸"),
-        (0x2F83E, "M", "呈"),
-        (0x2F83F, "M", "周"),
-        (0x2F840, "M", "咢"),
-        (0x2F841, "M", "哶"),
-        (0x2F842, "M", "唐"),
-        (0x2F843, "M", "啓"),
-        (0x2F844, "M", "啣"),
-        (0x2F845, "M", "善"),
-        (0x2F847, "M", "喙"),
-        (0x2F848, "M", "喫"),
-        (0x2F849, "M", "喳"),
-        (0x2F84A, "M", "嗂"),
-        (0x2F84B, "M", "圖"),
-        (0x2F84C, "M", "嘆"),
-        (0x2F84D, "M", "圗"),
-        (0x2F84E, "M", "噑"),
-        (0x2F84F, "M", "噴"),
-        (0x2F850, "M", "切"),
-        (0x2F851, "M", "壮"),
-        (0x2F852, "M", "城"),
-        (0x2F853, "M", "埴"),
-        (0x2F854, "M", "堍"),
-        (0x2F855, "M", "型"),
-        (0x2F856, "M", "堲"),
-        (0x2F857, "M", "報"),
-        (0x2F858, "M", "墬"),
-        (0x2F859, "M", "𡓤"),
-        (0x2F85A, "M", "売"),
-        (0x2F85B, "M", "壷"),
-    ]
-
-
-def _seg_75():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F85C, "M", "夆"),
-        (0x2F85D, "M", "多"),
-        (0x2F85E, "M", "夢"),
-        (0x2F85F, "M", "奢"),
-        (0x2F860, "M", "𡚨"),
-        (0x2F861, "M", "𡛪"),
-        (0x2F862, "M", "姬"),
-        (0x2F863, "M", "娛"),
-        (0x2F864, "M", "娧"),
-        (0x2F865, "M", "姘"),
-        (0x2F866, "M", "婦"),
-        (0x2F867, "M", "㛮"),
-        (0x2F868, "X"),
-        (0x2F869, "M", "嬈"),
-        (0x2F86A, "M", "嬾"),
-        (0x2F86C, "M", "𡧈"),
-        (0x2F86D, "M", "寃"),
-        (0x2F86E, "M", "寘"),
-        (0x2F86F, "M", "寧"),
-        (0x2F870, "M", "寳"),
-        (0x2F871, "M", "𡬘"),
-        (0x2F872, "M", "寿"),
-        (0x2F873, "M", "将"),
-        (0x2F874, "X"),
-        (0x2F875, "M", "尢"),
-        (0x2F876, "M", "㞁"),
-        (0x2F877, "M", "屠"),
-        (0x2F878, "M", "屮"),
-        (0x2F879, "M", "峀"),
-        (0x2F87A, "M", "岍"),
-        (0x2F87B, "M", "𡷤"),
-        (0x2F87C, "M", "嵃"),
-        (0x2F87D, "M", "𡷦"),
-        (0x2F87E, "M", "嵮"),
-        (0x2F87F, "M", "嵫"),
-        (0x2F880, "M", "嵼"),
-        (0x2F881, "M", "巡"),
-        (0x2F882, "M", "巢"),
-        (0x2F883, "M", "㠯"),
-        (0x2F884, "M", "巽"),
-        (0x2F885, "M", "帨"),
-        (0x2F886, "M", "帽"),
-        (0x2F887, "M", "幩"),
-        (0x2F888, "M", "㡢"),
-        (0x2F889, "M", "𢆃"),
-        (0x2F88A, "M", "㡼"),
-        (0x2F88B, "M", "庰"),
-        (0x2F88C, "M", "庳"),
-        (0x2F88D, "M", "庶"),
-        (0x2F88E, "M", "廊"),
-        (0x2F88F, "M", "𪎒"),
-        (0x2F890, "M", "廾"),
-        (0x2F891, "M", "𢌱"),
-        (0x2F893, "M", "舁"),
-        (0x2F894, "M", "弢"),
-        (0x2F896, "M", "㣇"),
-        (0x2F897, "M", "𣊸"),
-        (0x2F898, "M", "𦇚"),
-        (0x2F899, "M", "形"),
-        (0x2F89A, "M", "彫"),
-        (0x2F89B, "M", "㣣"),
-        (0x2F89C, "M", "徚"),
-        (0x2F89D, "M", "忍"),
-        (0x2F89E, "M", "志"),
-        (0x2F89F, "M", "忹"),
-        (0x2F8A0, "M", "悁"),
-        (0x2F8A1, "M", "㤺"),
-        (0x2F8A2, "M", "㤜"),
-        (0x2F8A3, "M", "悔"),
-        (0x2F8A4, "M", "𢛔"),
-        (0x2F8A5, "M", "惇"),
-        (0x2F8A6, "M", "慈"),
-        (0x2F8A7, "M", "慌"),
-        (0x2F8A8, "M", "慎"),
-        (0x2F8A9, "M", "慌"),
-        (0x2F8AA, "M", "慺"),
-        (0x2F8AB, "M", "憎"),
-        (0x2F8AC, "M", "憲"),
-        (0x2F8AD, "M", "憤"),
-        (0x2F8AE, "M", "憯"),
-        (0x2F8AF, "M", "懞"),
-        (0x2F8B0, "M", "懲"),
-        (0x2F8B1, "M", "懶"),
-        (0x2F8B2, "M", "成"),
-        (0x2F8B3, "M", "戛"),
-        (0x2F8B4, "M", "扝"),
-        (0x2F8B5, "M", "抱"),
-        (0x2F8B6, "M", "拔"),
-        (0x2F8B7, "M", "捐"),
-        (0x2F8B8, "M", "𢬌"),
-        (0x2F8B9, "M", "挽"),
-        (0x2F8BA, "M", "拼"),
-        (0x2F8BB, "M", "捨"),
-        (0x2F8BC, "M", "掃"),
-        (0x2F8BD, "M", "揤"),
-        (0x2F8BE, "M", "𢯱"),
-        (0x2F8BF, "M", "搢"),
-        (0x2F8C0, "M", "揅"),
-        (0x2F8C1, "M", "掩"),
-        (0x2F8C2, "M", "㨮"),
-    ]
-
-
-def _seg_76():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F8C3, "M", "摩"),
-        (0x2F8C4, "M", "摾"),
-        (0x2F8C5, "M", "撝"),
-        (0x2F8C6, "M", "摷"),
-        (0x2F8C7, "M", "㩬"),
-        (0x2F8C8, "M", "敏"),
-        (0x2F8C9, "M", "敬"),
-        (0x2F8CA, "M", "𣀊"),
-        (0x2F8CB, "M", "旣"),
-        (0x2F8CC, "M", "書"),
-        (0x2F8CD, "M", "晉"),
-        (0x2F8CE, "M", "㬙"),
-        (0x2F8CF, "M", "暑"),
-        (0x2F8D0, "M", "㬈"),
-        (0x2F8D1, "M", "㫤"),
-        (0x2F8D2, "M", "冒"),
-        (0x2F8D3, "M", "冕"),
-        (0x2F8D4, "M", "最"),
-        (0x2F8D5, "M", "暜"),
-        (0x2F8D6, "M", "肭"),
-        (0x2F8D7, "M", "䏙"),
-        (0x2F8D8, "M", "朗"),
-        (0x2F8D9, "M", "望"),
-        (0x2F8DA, "M", "朡"),
-        (0x2F8DB, "M", "杞"),
-        (0x2F8DC, "M", "杓"),
-        (0x2F8DD, "M", "𣏃"),
-        (0x2F8DE, "M", "㭉"),
-        (0x2F8DF, "M", "柺"),
-        (0x2F8E0, "M", "枅"),
-        (0x2F8E1, "M", "桒"),
-        (0x2F8E2, "M", "梅"),
-        (0x2F8E3, "M", "𣑭"),
-        (0x2F8E4, "M", "梎"),
-        (0x2F8E5, "M", "栟"),
-        (0x2F8E6, "M", "椔"),
-        (0x2F8E7, "M", "㮝"),
-        (0x2F8E8, "M", "楂"),
-        (0x2F8E9, "M", "榣"),
-        (0x2F8EA, "M", "槪"),
-        (0x2F8EB, "M", "檨"),
-        (0x2F8EC, "M", "𣚣"),
-        (0x2F8ED, "M", "櫛"),
-        (0x2F8EE, "M", "㰘"),
-        (0x2F8EF, "M", "次"),
-        (0x2F8F0, "M", "𣢧"),
-        (0x2F8F1, "M", "歔"),
-        (0x2F8F2, "M", "㱎"),
-        (0x2F8F3, "M", "歲"),
-        (0x2F8F4, "M", "殟"),
-        (0x2F8F5, "M", "殺"),
-        (0x2F8F6, "M", "殻"),
-        (0x2F8F7, "M", "𣪍"),
-        (0x2F8F8, "M", "𡴋"),
-        (0x2F8F9, "M", "𣫺"),
-        (0x2F8FA, "M", "汎"),
-        (0x2F8FB, "M", "𣲼"),
-        (0x2F8FC, "M", "沿"),
-        (0x2F8FD, "M", "泍"),
-        (0x2F8FE, "M", "汧"),
-        (0x2F8FF, "M", "洖"),
-        (0x2F900, "M", "派"),
-        (0x2F901, "M", "海"),
-        (0x2F902, "M", "流"),
-        (0x2F903, "M", "浩"),
-        (0x2F904, "M", "浸"),
-        (0x2F905, "M", "涅"),
-        (0x2F906, "M", "𣴞"),
-        (0x2F907, "M", "洴"),
-        (0x2F908, "M", "港"),
-        (0x2F909, "M", "湮"),
-        (0x2F90A, "M", "㴳"),
-        (0x2F90B, "M", "滋"),
-        (0x2F90C, "M", "滇"),
-        (0x2F90D, "M", "𣻑"),
-        (0x2F90E, "M", "淹"),
-        (0x2F90F, "M", "潮"),
-        (0x2F910, "M", "𣽞"),
-        (0x2F911, "M", "𣾎"),
-        (0x2F912, "M", "濆"),
-        (0x2F913, "M", "瀹"),
-        (0x2F914, "M", "瀞"),
-        (0x2F915, "M", "瀛"),
-        (0x2F916, "M", "㶖"),
-        (0x2F917, "M", "灊"),
-        (0x2F918, "M", "災"),
-        (0x2F919, "M", "灷"),
-        (0x2F91A, "M", "炭"),
-        (0x2F91B, "M", "𠔥"),
-        (0x2F91C, "M", "煅"),
-        (0x2F91D, "M", "𤉣"),
-        (0x2F91E, "M", "熜"),
-        (0x2F91F, "X"),
-        (0x2F920, "M", "爨"),
-        (0x2F921, "M", "爵"),
-        (0x2F922, "M", "牐"),
-        (0x2F923, "M", "𤘈"),
-        (0x2F924, "M", "犀"),
-        (0x2F925, "M", "犕"),
-        (0x2F926, "M", "𤜵"),
-    ]
-
-
-def _seg_77():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F927, "M", "𤠔"),
-        (0x2F928, "M", "獺"),
-        (0x2F929, "M", "王"),
-        (0x2F92A, "M", "㺬"),
-        (0x2F92B, "M", "玥"),
-        (0x2F92C, "M", "㺸"),
-        (0x2F92E, "M", "瑇"),
-        (0x2F92F, "M", "瑜"),
-        (0x2F930, "M", "瑱"),
-        (0x2F931, "M", "璅"),
-        (0x2F932, "M", "瓊"),
-        (0x2F933, "M", "㼛"),
-        (0x2F934, "M", "甤"),
-        (0x2F935, "M", "𤰶"),
-        (0x2F936, "M", "甾"),
-        (0x2F937, "M", "𤲒"),
-        (0x2F938, "M", "異"),
-        (0x2F939, "M", "𢆟"),
-        (0x2F93A, "M", "瘐"),
-        (0x2F93B, "M", "𤾡"),
-        (0x2F93C, "M", "𤾸"),
-        (0x2F93D, "M", "𥁄"),
-        (0x2F93E, "M", "㿼"),
-        (0x2F93F, "M", "䀈"),
-        (0x2F940, "M", "直"),
-        (0x2F941, "M", "𥃳"),
-        (0x2F942, "M", "𥃲"),
-        (0x2F943, "M", "𥄙"),
-        (0x2F944, "M", "𥄳"),
-        (0x2F945, "M", "眞"),
-        (0x2F946, "M", "真"),
-        (0x2F948, "M", "睊"),
-        (0x2F949, "M", "䀹"),
-        (0x2F94A, "M", "瞋"),
-        (0x2F94B, "M", "䁆"),
-        (0x2F94C, "M", "䂖"),
-        (0x2F94D, "M", "𥐝"),
-        (0x2F94E, "M", "硎"),
-        (0x2F94F, "M", "碌"),
-        (0x2F950, "M", "磌"),
-        (0x2F951, "M", "䃣"),
-        (0x2F952, "M", "𥘦"),
-        (0x2F953, "M", "祖"),
-        (0x2F954, "M", "𥚚"),
-        (0x2F955, "M", "𥛅"),
-        (0x2F956, "M", "福"),
-        (0x2F957, "M", "秫"),
-        (0x2F958, "M", "䄯"),
-        (0x2F959, "M", "穀"),
-        (0x2F95A, "M", "穊"),
-        (0x2F95B, "M", "穏"),
-        (0x2F95C, "M", "𥥼"),
-        (0x2F95D, "M", "𥪧"),
-        (0x2F95F, "X"),
-        (0x2F960, "M", "䈂"),
-        (0x2F961, "M", "𥮫"),
-        (0x2F962, "M", "篆"),
-        (0x2F963, "M", "築"),
-        (0x2F964, "M", "䈧"),
-        (0x2F965, "M", "𥲀"),
-        (0x2F966, "M", "糒"),
-        (0x2F967, "M", "䊠"),
-        (0x2F968, "M", "糨"),
-        (0x2F969, "M", "糣"),
-        (0x2F96A, "M", "紀"),
-        (0x2F96B, "M", "𥾆"),
-        (0x2F96C, "M", "絣"),
-        (0x2F96D, "M", "䌁"),
-        (0x2F96E, "M", "緇"),
-        (0x2F96F, "M", "縂"),
-        (0x2F970, "M", "繅"),
-        (0x2F971, "M", "䌴"),
-        (0x2F972, "M", "𦈨"),
-        (0x2F973, "M", "𦉇"),
-        (0x2F974, "M", "䍙"),
-        (0x2F975, "M", "𦋙"),
-        (0x2F976, "M", "罺"),
-        (0x2F977, "M", "𦌾"),
-        (0x2F978, "M", "羕"),
-        (0x2F979, "M", "翺"),
-        (0x2F97A, "M", "者"),
-        (0x2F97B, "M", "𦓚"),
-        (0x2F97C, "M", "𦔣"),
-        (0x2F97D, "M", "聠"),
-        (0x2F97E, "M", "𦖨"),
-        (0x2F97F, "M", "聰"),
-        (0x2F980, "M", "𣍟"),
-        (0x2F981, "M", "䏕"),
-        (0x2F982, "M", "育"),
-        (0x2F983, "M", "脃"),
-        (0x2F984, "M", "䐋"),
-        (0x2F985, "M", "脾"),
-        (0x2F986, "M", "媵"),
-        (0x2F987, "M", "𦞧"),
-        (0x2F988, "M", "𦞵"),
-        (0x2F989, "M", "𣎓"),
-        (0x2F98A, "M", "𣎜"),
-        (0x2F98B, "M", "舁"),
-        (0x2F98C, "M", "舄"),
-        (0x2F98D, "M", "辞"),
-    ]
-
-
-def _seg_78():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F98E, "M", "䑫"),
-        (0x2F98F, "M", "芑"),
-        (0x2F990, "M", "芋"),
-        (0x2F991, "M", "芝"),
-        (0x2F992, "M", "劳"),
-        (0x2F993, "M", "花"),
-        (0x2F994, "M", "芳"),
-        (0x2F995, "M", "芽"),
-        (0x2F996, "M", "苦"),
-        (0x2F997, "M", "𦬼"),
-        (0x2F998, "M", "若"),
-        (0x2F999, "M", "茝"),
-        (0x2F99A, "M", "荣"),
-        (0x2F99B, "M", "莭"),
-        (0x2F99C, "M", "茣"),
-        (0x2F99D, "M", "莽"),
-        (0x2F99E, "M", "菧"),
-        (0x2F99F, "M", "著"),
-        (0x2F9A0, "M", "荓"),
-        (0x2F9A1, "M", "菊"),
-        (0x2F9A2, "M", "菌"),
-        (0x2F9A3, "M", "菜"),
-        (0x2F9A4, "M", "𦰶"),
-        (0x2F9A5, "M", "𦵫"),
-        (0x2F9A6, "M", "𦳕"),
-        (0x2F9A7, "M", "䔫"),
-        (0x2F9A8, "M", "蓱"),
-        (0x2F9A9, "M", "蓳"),
-        (0x2F9AA, "M", "蔖"),
-        (0x2F9AB, "M", "𧏊"),
-        (0x2F9AC, "M", "蕤"),
-        (0x2F9AD, "M", "𦼬"),
-        (0x2F9AE, "M", "䕝"),
-        (0x2F9AF, "M", "䕡"),
-        (0x2F9B0, "M", "𦾱"),
-        (0x2F9B1, "M", "𧃒"),
-        (0x2F9B2, "M", "䕫"),
-        (0x2F9B3, "M", "虐"),
-        (0x2F9B4, "M", "虜"),
-        (0x2F9B5, "M", "虧"),
-        (0x2F9B6, "M", "虩"),
-        (0x2F9B7, "M", "蚩"),
-        (0x2F9B8, "M", "蚈"),
-        (0x2F9B9, "M", "蜎"),
-        (0x2F9BA, "M", "蛢"),
-        (0x2F9BB, "M", "蝹"),
-        (0x2F9BC, "M", "蜨"),
-        (0x2F9BD, "M", "蝫"),
-        (0x2F9BE, "M", "螆"),
-        (0x2F9BF, "X"),
-        (0x2F9C0, "M", "蟡"),
-        (0x2F9C1, "M", "蠁"),
-        (0x2F9C2, "M", "䗹"),
-        (0x2F9C3, "M", "衠"),
-        (0x2F9C4, "M", "衣"),
-        (0x2F9C5, "M", "𧙧"),
-        (0x2F9C6, "M", "裗"),
-        (0x2F9C7, "M", "裞"),
-        (0x2F9C8, "M", "䘵"),
-        (0x2F9C9, "M", "裺"),
-        (0x2F9CA, "M", "㒻"),
-        (0x2F9CB, "M", "𧢮"),
-        (0x2F9CC, "M", "𧥦"),
-        (0x2F9CD, "M", "䚾"),
-        (0x2F9CE, "M", "䛇"),
-        (0x2F9CF, "M", "誠"),
-        (0x2F9D0, "M", "諭"),
-        (0x2F9D1, "M", "變"),
-        (0x2F9D2, "M", "豕"),
-        (0x2F9D3, "M", "𧲨"),
-        (0x2F9D4, "M", "貫"),
-        (0x2F9D5, "M", "賁"),
-        (0x2F9D6, "M", "贛"),
-        (0x2F9D7, "M", "起"),
-        (0x2F9D8, "M", "𧼯"),
-        (0x2F9D9, "M", "𠠄"),
-        (0x2F9DA, "M", "跋"),
-        (0x2F9DB, "M", "趼"),
-        (0x2F9DC, "M", "跰"),
-        (0x2F9DD, "M", "𠣞"),
-        (0x2F9DE, "M", "軔"),
-        (0x2F9DF, "M", "輸"),
-        (0x2F9E0, "M", "𨗒"),
-        (0x2F9E1, "M", "𨗭"),
-        (0x2F9E2, "M", "邔"),
-        (0x2F9E3, "M", "郱"),
-        (0x2F9E4, "M", "鄑"),
-        (0x2F9E5, "M", "𨜮"),
-        (0x2F9E6, "M", "鄛"),
-        (0x2F9E7, "M", "鈸"),
-        (0x2F9E8, "M", "鋗"),
-        (0x2F9E9, "M", "鋘"),
-        (0x2F9EA, "M", "鉼"),
-        (0x2F9EB, "M", "鏹"),
-        (0x2F9EC, "M", "鐕"),
-        (0x2F9ED, "M", "𨯺"),
-        (0x2F9EE, "M", "開"),
-        (0x2F9EF, "M", "䦕"),
-        (0x2F9F0, "M", "閷"),
-        (0x2F9F1, "M", "𨵷"),
-    ]
-
-
-def _seg_79():
-    # type: () -> List[Union[Tuple[int, str], Tuple[int, str, str]]]
-    return [
-        (0x2F9F2, "M", "䧦"),
-        (0x2F9F3, "M", "雃"),
-        (0x2F9F4, "M", "嶲"),
-        (0x2F9F5, "M", "霣"),
-        (0x2F9F6, "M", "𩅅"),
-        (0x2F9F7, "M", "𩈚"),
-        (0x2F9F8, "M", "䩮"),
-        (0x2F9F9, "M", "䩶"),
-        (0x2F9FA, "M", "韠"),
-        (0x2F9FB, "M", "𩐊"),
-        (0x2F9FC, "M", "䪲"),
-        (0x2F9FD, "M", "𩒖"),
-        (0x2F9FE, "M", "頋"),
-        (0x2FA00, "M", "頩"),
-        (0x2FA01, "M", "𩖶"),
-        (0x2FA02, "M", "飢"),
-        (0x2FA03, "M", "䬳"),
-        (0x2FA04, "M", "餩"),
-        (0x2FA05, "M", "馧"),
-        (0x2FA06, "M", "駂"),
-        (0x2FA07, "M", "駾"),
-        (0x2FA08, "M", "䯎"),
-        (0x2FA09, "M", "𩬰"),
-        (0x2FA0A, "M", "鬒"),
-        (0x2FA0B, "M", "鱀"),
-        (0x2FA0C, "M", "鳽"),
-        (0x2FA0D, "M", "䳎"),
-        (0x2FA0E, "M", "䳭"),
-        (0x2FA0F, "M", "鵧"),
-        (0x2FA10, "M", "𪃎"),
-        (0x2FA11, "M", "䳸"),
-        (0x2FA12, "M", "𪄅"),
-        (0x2FA13, "M", "𪈎"),
-        (0x2FA14, "M", "𪊑"),
-        (0x2FA15, "M", "麻"),
-        (0x2FA16, "M", "䵖"),
-        (0x2FA17, "M", "黹"),
-        (0x2FA18, "M", "黾"),
-        (0x2FA19, "M", "鼅"),
-        (0x2FA1A, "M", "鼏"),
-        (0x2FA1B, "M", "鼖"),
-        (0x2FA1C, "M", "鼻"),
-        (0x2FA1D, "M", "𪘀"),
-        (0x2FA1E, "X"),
-        (0x30000, "V"),
-        (0x3134B, "X"),
-        (0xE0100, "I"),
-        (0xE01F0, "X"),
-    ]
-
-
-uts46data = tuple(
-    _seg_0()
-    + _seg_1()
-    + _seg_2()
-    + _seg_3()
-    + _seg_4()
-    + _seg_5()
-    + _seg_6()
-    + _seg_7()
-    + _seg_8()
-    + _seg_9()
-    + _seg_10()
-    + _seg_11()
-    + _seg_12()
-    + _seg_13()
-    + _seg_14()
-    + _seg_15()
-    + _seg_16()
-    + _seg_17()
-    + _seg_18()
-    + _seg_19()
-    + _seg_20()
-    + _seg_21()
-    + _seg_22()
-    + _seg_23()
-    + _seg_24()
-    + _seg_25()
-    + _seg_26()
-    + _seg_27()
-    + _seg_28()
-    + _seg_29()
-    + _seg_30()
-    + _seg_31()
-    + _seg_32()
-    + _seg_33()
-    + _seg_34()
-    + _seg_35()
-    + _seg_36()
-    + _seg_37()
-    + _seg_38()
-    + _seg_39()
-    + _seg_40()
-    + _seg_41()
-    + _seg_42()
-    + _seg_43()
-    + _seg_44()
-    + _seg_45()
-    + _seg_46()
-    + _seg_47()
-    + _seg_48()
-    + _seg_49()
-    + _seg_50()
-    + _seg_51()
-    + _seg_52()
-    + _seg_53()
-    + _seg_54()
-    + _seg_55()
-    + _seg_56()
-    + _seg_57()
-    + _seg_58()
-    + _seg_59()
-    + _seg_60()
-    + _seg_61()
-    + _seg_62()
-    + _seg_63()
-    + _seg_64()
-    + _seg_65()
-    + _seg_66()
-    + _seg_67()
-    + _seg_68()
-    + _seg_69()
-    + _seg_70()
-    + _seg_71()
-    + _seg_72()
-    + _seg_73()
-    + _seg_74()
-    + _seg_75()
-    + _seg_76()
-    + _seg_77()
-    + _seg_78()
-    + _seg_79()
-)  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/addon/globalPlugins/spellcheck/libs/sniffio/__init__.py b/addon/globalPlugins/spellcheck/libs/sniffio/__init__.py
index 347bf34..63f2f19 100644
--- a/addon/globalPlugins/spellcheck/libs/sniffio/__init__.py
+++ b/addon/globalPlugins/spellcheck/libs/sniffio/__init__.py
@@ -4,6 +4,7 @@
     "current_async_library",
     "AsyncLibraryNotFoundError",
     "current_async_library_cvar",
+    "thread_local",
 ]
 
 from ._version import __version__
@@ -12,4 +13,5 @@
     current_async_library,
     AsyncLibraryNotFoundError,
     current_async_library_cvar,
+    thread_local,
 )
diff --git a/addon/globalPlugins/spellcheck/libs/sniffio/_impl.py b/addon/globalPlugins/spellcheck/libs/sniffio/_impl.py
index 1a0f152..c1a7bbf 100644
--- a/addon/globalPlugins/spellcheck/libs/sniffio/_impl.py
+++ b/addon/globalPlugins/spellcheck/libs/sniffio/_impl.py
@@ -1,12 +1,23 @@
 from contextvars import ContextVar
 from typing import Optional
 import sys
+import threading
 
 current_async_library_cvar = ContextVar(
     "current_async_library_cvar", default=None
 )  # type: ContextVar[Optional[str]]
 
 
+class _ThreadLocal(threading.local):
+    # Since threading.local provides no explicit mechanism is for setting
+    # a default for a value, a custom class with a class attribute is used
+    # instead.
+    name = None  # type: Optional[str]
+
+
+thread_local = _ThreadLocal()
+
+
 class AsyncLibraryNotFoundError(RuntimeError):
     pass
 
@@ -52,32 +63,33 @@ async def generic_sleep(seconds):
                    raise RuntimeError(f"Unsupported library {library!r}")
 
     """
-    value = current_async_library_cvar.get()
+    value = thread_local.name
     if value is not None:
         return value
 
-    # Sniff for curio (for now)
-    if "curio" in sys.modules:
-        from curio.meta import curio_running
-
-        if curio_running():
-            return "curio"
+    value = current_async_library_cvar.get()
+    if value is not None:
+        return value
 
     # Need to sniff for asyncio
     if "asyncio" in sys.modules:
         import asyncio
-
         try:
             current_task = asyncio.current_task  # type: ignore[attr-defined]
         except AttributeError:
             current_task = asyncio.Task.current_task  # type: ignore[attr-defined]
         try:
             if current_task() is not None:
-                if (3, 7) <= sys.version_info:
-                    # asyncio has contextvars support, and we're in a task, so
-                    # we can safely cache the sniffed value
-                    current_async_library_cvar.set("asyncio")
                 return "asyncio"
         except RuntimeError:
             pass
-    raise AsyncLibraryNotFoundError("unknown async library, or not in async context")
+
+    # Sniff for curio (for now)
+    if 'curio' in sys.modules:
+        from curio.meta import curio_running
+        if curio_running():
+            return 'curio'
+
+    raise AsyncLibraryNotFoundError(
+        "unknown async library, or not in async context"
+    )
diff --git a/addon/globalPlugins/spellcheck/libs/sniffio/_tests/test_sniffio.py b/addon/globalPlugins/spellcheck/libs/sniffio/_tests/test_sniffio.py
index 315a7e5..02945a9 100644
--- a/addon/globalPlugins/spellcheck/libs/sniffio/_tests/test_sniffio.py
+++ b/addon/globalPlugins/spellcheck/libs/sniffio/_tests/test_sniffio.py
@@ -1,15 +1,15 @@
+import os
 import sys
 
 import pytest
 
 from .. import (
-    current_async_library,
-    AsyncLibraryNotFoundError,
-    current_async_library_cvar,
+    current_async_library, AsyncLibraryNotFoundError,
+    current_async_library_cvar, thread_local
 )
 
 
-def test_basics():
+def test_basics_cvar():
     with pytest.raises(AsyncLibraryNotFoundError):
         current_async_library()
 
@@ -23,6 +23,20 @@ def test_basics():
         current_async_library()
 
 
+def test_basics_tlocal():
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+    old_name, thread_local.name = thread_local.name, "generic-lib"
+    try:
+        assert current_async_library() == "generic-lib"
+    finally:
+        thread_local.name = old_name
+
+    with pytest.raises(AsyncLibraryNotFoundError):
+        current_async_library()
+
+
 def test_asyncio():
     import asyncio
 
@@ -37,16 +51,18 @@ async def this_is_asyncio():
         assert current_async_library() == "asyncio"
         ran.append(True)
 
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(this_is_asyncio())
+    asyncio.run(this_is_asyncio())
     assert ran == [True]
-    loop.close()
 
     with pytest.raises(AsyncLibraryNotFoundError):
         current_async_library()
 
 
-@pytest.mark.skipif(sys.version_info < (3, 6), reason="Curio requires 3.6+")
+@pytest.mark.skipif(
+    sys.version_info >= (3, 12),
+    reason=
+    "curio broken on 3.12 (https://github.com/python-trio/sniffio/pull/42)",
+)
 def test_curio():
     import curio
 
diff --git a/addon/globalPlugins/spellcheck/libs/sniffio/_version.py b/addon/globalPlugins/spellcheck/libs/sniffio/_version.py
index 7c4b119..0495d10 100644
--- a/addon/globalPlugins/spellcheck/libs/sniffio/_version.py
+++ b/addon/globalPlugins/spellcheck/libs/sniffio/_version.py
@@ -1,3 +1,3 @@
 # This file is imported from __init__.py and exec'd from setup.py
 
-__version__ = "1.2.0"
+__version__ = "1.3.1"
diff --git a/addon/globalPlugins/spellcheck/spellcheck_ui.py b/addon/globalPlugins/spellcheck/spellcheck_ui.py
index 7b0b0e3..cde26c2 100644
--- a/addon/globalPlugins/spellcheck/spellcheck_ui.py
+++ b/addon/globalPlugins/spellcheck/spellcheck_ui.py
@@ -210,7 +210,7 @@ def on_user_choice(self, choice):
         self._user_choice = choice
         if choice.choice_type is UserChoiceType.SUGGESTION:
             # translators: appears between the misspelled word and the selected suggestion by the user.
-            desc = _("accepted: {suggestion}").format(suggestion=choice.name)
+            desc = _(f"accepted: {choice.name}")
         elif choice.choice_type is UserChoiceType.IGNORE_FOR_THIS_SESSION:
             eventHandler.queueEvent("suggestionsClosed", FakeEditableNVDAObject())
             self.parent.ignore_for_this_session(self)
diff --git a/addon/locale/es/LC_MESSAGES/nvda.po b/addon/locale/es/LC_MESSAGES/nvda.po
new file mode 100644
index 0000000..8618d56
--- /dev/null
+++ b/addon/locale/es/LC_MESSAGES/nvda.po
@@ -0,0 +1,207 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the 'spellcheck' package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: 'spellcheck' '1.2'\n"
+"Report-Msgid-Bugs-To: 'nvda-translations@groups.io'\n"
+"POT-Creation-Date: 2024-05-05 18:01-0600\n"
+"PO-Revision-Date: 2024-05-05 18:04-0600\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"X-Generator: Poedit 2.4.2\n"
+"Last-Translator: \n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Language: es\n"
+
+#. Translators: script category for Spellcheck add-on
+#. Add-on summary, usually the user visible name of the addon.
+#. Translators: Summary for this add-on
+#. to be shown on installation and add-on information found in Add-ons Manager.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:45 buildVars.py:30
+msgid "Spellcheck"
+msgstr "Corrector ortográfico"
+
+#. translators: appears between the misspelled word and the selected suggestion by the user.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:213
+#, python-brace-format
+msgid "accepted: {choice.name}"
+msgstr "aceptado: {elección.nombre}"
+
+#. translators: appears in the misspelled words menu when a user chooses to add the erroneous word to the personal dictionary.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:220
+msgid "Added to personal dictionary"
+msgstr "Agregado al diccionario personal"
+
+#. translators: name of the option in the suggestion menu
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:259
+msgid "Ignore for this session"
+msgstr "Ignorar para esta sesión"
+
+#. translators: name of the option in the suggestion menu.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:265
+msgid "Add to dictionary"
+msgstr "Añadir al diccionario"
+
+#. translators: appears in the NVDA input help.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:305
+msgid "Copies the corrected text to the clipboard"
+msgstr "Copia el texto corregido al portapapeles."
+
+#. translators: appears in the NVDA input help.
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:314
+msgid "Replaces the text in the edit field with the corrected text"
+msgstr "Reemplaza el texto en el campo de edición con el texto corregido"
+
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:432
+msgid "No misspellings"
+msgstr "Sin errores ortográficos"
+
+#: addon\globalPlugins\spellcheck\spellcheck_ui.py:451
+msgid "Can not replace text, the text field is read only"
+msgstr "No se puede reemplazar el texto, el campo de texto es de solo lectura"
+
+#. Translators: message of a progress dialog
+#: addon\globalPlugins\spellcheck\__init__.py:76
+#, python-brace-format
+msgid "Downloaded: {progress}%"
+msgstr "Descargado: {progreso}%"
+
+#: addon\globalPlugins\spellcheck\__init__.py:86
+#, python-brace-format
+msgid "Successfully downloaded dictionary for  language {lang}"
+msgstr "Diccionario descargado correctamente para el idioma {lang}"
+
+#: addon\globalPlugins\spellcheck\__init__.py:89
+msgid "Dictionary Downloaded"
+msgstr "Diccionario descargado"
+
+#: addon\globalPlugins\spellcheck\__init__.py:96
+#, python-brace-format
+msgid ""
+"Cannot download dictionary for language {lang}.\n"
+"Please check your connection and try again."
+msgstr ""
+"No se puede descargar el diccionario del idioma {lang}.\\n\n"
+"Por favor, compruebe la conexión y vuelva a intentarlo."
+
+#: addon\globalPlugins\spellcheck\__init__.py:98
+msgid "Download Failed"
+msgstr "Descarga fallida"
+
+#: addon\globalPlugins\spellcheck\__init__.py:109
+#, python-brace-format
+msgid ""
+"Dictionary for language {lang} is missing.\n"
+"Would you like to download it?"
+msgstr ""
+"Falta el diccionario del idioma {lang}.\\n\n"
+"¿Quieres descargarlo?"
+
+#: addon\globalPlugins\spellcheck\__init__.py:111
+msgid "Download Language Dictionary"
+msgstr "Descargar Diccionario de Idiomas"
+
+#. Translators: title of a progress dialog
+#: addon\globalPlugins\spellcheck\__init__.py:119
+#, python-brace-format
+msgid "Downloading Dictionary For Language {lang}"
+msgstr "Descarga del diccionario de idiomas {lang}"
+
+#. Translators: message of a progress dialog
+#: addon\globalPlugins\spellcheck\__init__.py:123
+msgid "Retrieving download information..."
+msgstr "Recuperando información de descarga..."
+
+#: addon\globalPlugins\spellcheck\__init__.py:149
+msgid ""
+"Checks spelling errors for the selected text using the current input language"
+msgstr ""
+"Comprueba los errores ortográficos del texto seleccionado utilizando el "
+"idioma de entrada actual"
+
+#: addon\globalPlugins\spellcheck\__init__.py:169
+msgid ""
+"Toggles the method used in determining the language for spellchecking: user-"
+"chosen versus current input language"
+msgstr ""
+"Alterna el método utilizado para determinar el idioma para la revisión "
+"ortográfica: idioma de entrada elegido por el usuario versus idioma de "
+"entrada actual"
+
+#. Translators: spoken message when the dialog is already open
+#: addon\globalPlugins\spellcheck\__init__.py:179
+msgid "Dialog is already open"
+msgstr "El diálogo ya está abierto."
+
+#. Translators: message of a dialog containing language choices
+#: addon\globalPlugins\spellcheck\__init__.py:187
+msgid "Please choose the language you want to use for spellchecking."
+msgstr "Elija el idioma que desea utilizar para la revisión ortográfica."
+
+#. Translators: title of a dialog containing a list of languages
+#: addon\globalPlugins\spellcheck\__init__.py:189
+msgid "Choose Spellcheck Language"
+msgstr "Elija el idioma del corrector ortográfico"
+
+#: addon\globalPlugins\spellcheck\__init__.py:201
+msgid "Using the active Input language for spellchecking"
+msgstr "Uso del idioma de entrada activo para la revisión ortográfica"
+
+#. translators: the name of the menu that shows up when the addon is being activated.
+#: addon\globalPlugins\spellcheck\__init__.py:211
+msgid "Spelling Errors"
+msgstr "Errores de ortografía"
+
+#: addon\globalPlugins\spellcheck\__init__.py:235
+#, python-brace-format
+msgid ""
+"Dialects found for language {lang}.\n"
+"Please select the one you want to download."
+msgstr ""
+"Dialectos encontrados para el idioma {lang}.\\n\n"
+"Seleccione el que desea descargar."
+
+#. Translators: title of a dialog containing a list of languages
+#: addon\globalPlugins\spellcheck\__init__.py:238
+msgid "Dialects Found"
+msgstr "Dialectos encontrados"
+
+#: addon\globalPlugins\spellcheck\__init__.py:250
+#, python-brace-format
+msgid "Language dictionary for language {lang} is not available."
+msgstr "El diccionario de idiomas para el idioma {lang} no está disponible."
+
+#: addon\globalPlugins\spellcheck\__init__.py:272
+msgid "Spellchecking is not supported here"
+msgstr "Aquí no se admite la corrección ortográfica"
+
+#: addon\globalPlugins\spellcheck\__init__.py:285
+msgid "No text is selected"
+msgstr "No hay ningún texto seleccionado."
+
+#: addon\installTasks.py:29
+msgid ""
+"The Spellcheck add-on comes bundled with some default language dictionaries. "
+"Would you like to add them?"
+msgstr ""
+"El complemento Spellcheck viene incluido con algunos diccionarios de idiomas "
+"predeterminados. ¿Quieres agregarlos?"
+
+#: addon\installTasks.py:30
+msgid "Add Default Dictionaries"
+msgstr "Agregar diccionarios predeterminados"
+
+#. Add-on description
+#. Translators: Long description to be shown for this add-on on add-on information from add-ons manager
+#: buildVars.py:33
+msgid ""
+"A multilingual spellchecker. Detects spelling mistakes in current selection "
+"and provide correction suggestions."
+msgstr ""
+"Un corrector ortográfico multilingüe. Detecta errores ortográficos en la "
+"selección actual y proporciona sugerencias de corrección."