robotcode-language-server 0.64.0__tar.gz → 0.65.1__tar.gz

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotcode-language-server
-Version: 0.64.0
+Version: 0.65.1
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://github.com/sponsors/d-biehl
@@ -25,8 +25,8 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-jsonrpc2==0.64.0
-Requires-Dist: robotcode==0.64.0
+Requires-Dist: robotcode-jsonrpc2==0.65.1
+Requires-Dist: robotcode==0.65.1
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/pyproject.toml

@@ -27,8 +27,8 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==0.64.0",
-  "robotcode==0.64.0",
+  "robotcode-jsonrpc2==0.65.1",
+  "robotcode==0.65.1",
 ]
 dynamic = ["version"]
 

robotcode_language_server-0.65.1/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.65.1"

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/src/robotcode/language_server/common/parts/code_lens.py

@@ -109,4 +109,4 @@ class CodeLensProtocolPart(LanguageServerProtocolPart, HasExtendCapabilities):
         ):
             return
 
-        await self.parent.send_request("workspace/codeLens/refresh")
+        await self.parent.send_request_async("workspace/codeLens/refresh")

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/src/robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -34,10 +34,8 @@ from typing import (
 )
 
 from robotcode.core.lsp.types import Position, Range
-from robotcode.language_server.robotframework.utils.markdownformatter import (
-    MarkDownFormatter,
-)
 from robotcode.robot.utils import get_robot_version
+from robotcode.robot.utils.markdownformatter import MarkDownFormatter
 
 from ..utils.ast_utils import (
     HasError,
@@ -442,7 +440,8 @@ class ArgumentSpec:
     var_named: Any
     embedded: Any
     defaults: Any
-    types: Any
+    types: Optional[Dict[str, str]] = None
+    return_type: Optional[str] = None
 
     @staticmethod
     def from_robot_argument_spec(spec: Any) -> ArgumentSpec:
@@ -456,7 +455,8 @@ class ArgumentSpec:
             var_named=spec.var_named,
             embedded=spec.embedded if get_robot_version() >= (7, 0) else None,
             defaults={k: str(v) for k, v in spec.defaults.items()} if spec.defaults else {},
-            types=None,
+            types={k: str(v) for k, v in spec.types.items()} if get_robot_version() > (7, 0) and spec.types else None,
+            return_type=str(spec.return_type) if get_robot_version() > (7, 0) and spec.return_type else None,
         )
 
     def resolve(
@@ -489,7 +489,7 @@ class ArgumentSpec:
                     self.named_only,
                     self.var_named,
                     self.defaults,
-                    self.types,
+                    None,
                 )
             else:
                 self.__robot_arguments = RobotArgumentSpec(
@@ -502,7 +502,7 @@ class ArgumentSpec:
                     self.var_named,
                     self.embedded,
                     self.defaults,
-                    self.types,
+                    None,
                 )
         self.__robot_arguments.name = self.name
         if validate:
@@ -553,6 +553,7 @@ class KeywordDoc(SourceEntity):
     is_registered_run_keyword: bool = field(default=False, compare=False)
     args_to_process: Optional[int] = field(default=None, compare=False)
     deprecated: bool = field(default=False, compare=False)
+    return_type: Optional[str] = field(default=None, compare=False)
 
     parent_digest: Optional[str] = field(default=None, init=False, metadata={"nosave": True})
     parent: Optional[LibraryDoc] = field(default=None, init=False, metadata={"nosave": True})
@@ -719,6 +720,11 @@ class KeywordDoc(SourceEntity):
                     f"| {'=' if a.default_value is not None else ''} "
                     f"| {f'`{a.default_value!s}`' if a.default_value else ''} |"
                 )
+        if self.return_type:
+            if result:
+                result += "\n\n"
+
+            result += f"**Return Type**: `{self.return_type}`\n"
 
         if self.tags:
             if result:
@@ -1801,6 +1807,7 @@ def get_library_doc(
                             arguments_spec=ArgumentSpec.from_robot_argument_spec(kw[1].arguments)
                             if not kw[1].is_error_handler
                             else None,
+                            return_type=str(kw[1].arguments.return_type) if get_robot_version() >= (7, 0) else None,
                         )
                         for kw in keyword_docs
                     ],

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/src/robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -24,9 +24,17 @@ from typing import (
     Set,
     Tuple,
     Union,
-    cast,
 )
 
+from robot.errors import VariableError
+from robot.libraries import STDLIBS
+from robot.parsing.lexer.tokens import Token
+from robot.parsing.model.blocks import Keyword, SettingSection, TestCase, VariableSection
+from robot.parsing.model.statements import Arguments, KeywordCall, KeywordName, Statement, Variable
+from robot.parsing.model.statements import LibraryImport as RobotLibraryImport
+from robot.parsing.model.statements import ResourceImport as RobotResourceImport
+from robot.parsing.model.statements import VariablesImport as RobotVariablesImport
+from robot.variables.search import is_scalar_assign, is_variable, search_variable
 from robotcode.core.async_tools import Lock, async_event
 from robotcode.core.logging import LoggingDescriptor
 from robotcode.core.lsp.types import (
@@ -42,16 +50,15 @@ from robotcode.core.lsp.types import (
 )
 from robotcode.core.uri import Uri
 from robotcode.robot.utils import get_robot_version
-
-from ...common.text_document import TextDocument
-from ..languages import Languages
-from ..utils.ast_utils import (
-    Token,
+from robotcode.robot.utils.ast import (
     range_from_node,
     range_from_token,
     strip_variable_token,
     tokenize_variables,
 )
+
+from ...common.text_document import TextDocument
+from ..languages import Languages
 from ..utils.async_ast import Visitor
 from ..utils.match import eq_namespace
 from ..utils.variables import BUILTIN_VARIABLES
@@ -111,19 +118,14 @@ class VariablesVisitor(Visitor):
         return self._results
 
     def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.model.blocks import VariableSection
-
         if isinstance(node, VariableSection):
             self.generic_visit(node)
 
-    def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import Variable
-        from robot.variables import search_variable
-
-        variable = cast(Variable, node)
+    def visit_Variable(self, node: Variable) -> None:  # noqa: N802
+        name_token = node.get_token(Token.VARIABLE)
+        if name_token is None:
+            return
 
-        name_token = variable.get_token(RobotToken.VARIABLE)
         name = name_token.value
 
         if name is not None:
@@ -134,21 +136,21 @@ class VariablesVisitor(Visitor):
             if name.endswith("="):
                 name = name[:-1].rstrip()
 
-            has_value = bool(variable.value)
+            has_value = bool(node.value)
             value = tuple(
-                s.replace("${CURDIR}", str(Path(self.source).parent).replace("\\", "\\\\")) for s in variable.value
+                s.replace("${CURDIR}", str(Path(self.source).parent).replace("\\", "\\\\")) for s in node.value
             )
 
             self._results.append(
                 VariableDefinition(
-                    name=variable.name,
+                    name=node.name,
                     name_token=strip_variable_token(
-                        RobotToken(name_token.type, name, name_token.lineno, name_token.col_offset, name_token.error)
+                        Token(name_token.type, name, name_token.lineno, name_token.col_offset, name_token.error)
                     ),
-                    line_no=variable.lineno,
-                    col_offset=variable.col_offset,
-                    end_line_no=variable.lineno,
-                    end_col_offset=variable.end_col_offset,
+                    line_no=node.lineno,
+                    col_offset=node.col_offset,
+                    end_line_no=node.lineno,
+                    end_col_offset=node.end_col_offset,
                     source=self.source,
                     has_value=has_value,
                     resolvable=True,
@@ -187,22 +189,17 @@ class BlockVariableVisitor(Visitor):
         finally:
             self.current_kw_doc = None
 
-    def visit_KeywordName(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import KeywordName
-        from robot.variables.search import search_variable
-
+    def visit_KeywordName(self, node: KeywordName) -> None:  # noqa: N802
         from .model_helper import ModelHelperMixin
 
-        n = cast(KeywordName, node)
-        name_token = cast(Token, n.get_token(RobotToken.KEYWORD_NAME))
+        name_token = node.get_token(Token.KEYWORD_NAME)
 
         if name_token is not None and name_token.value:
             keyword = ModelHelperMixin.get_keyword_definition_at_token(self.library_doc, name_token)
             self.current_kw_doc = keyword
 
             for variable_token in filter(
-                lambda e: e.type == RobotToken.VARIABLE,
+                lambda e: e.type == Token.VARIABLE,
                 tokenize_variables(name_token, identifiers="$", ignore_errors=True),
             ):
                 if variable_token.value:
@@ -225,30 +222,24 @@ class BlockVariableVisitor(Visitor):
                     )
 
     def get_variable_token(self, token: Token) -> Optional[Token]:
-        from robot.parsing.lexer.tokens import Token as RobotToken
-
         return next(
             (
                 v
                 for v in itertools.dropwhile(
-                    lambda t: t.type in RobotToken.NON_DATA_TOKENS,
-                    tokenize_variables(token, ignore_errors=True),
+                    lambda t: t.type in Token.NON_DATA_TOKENS,
+                    tokenize_variables(token, ignore_errors=True, extra_types={Token.VARIABLE}),
                 )
-                if v.type == RobotToken.VARIABLE
+                if v.type == Token.VARIABLE
             ),
             None,
         )
 
-    def visit_Arguments(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.errors import VariableError
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import Arguments
-
+    def visit_Arguments(self, node: Arguments) -> None:  # noqa: N802
         args: List[str] = []
-        n = cast(Arguments, node)
-        arguments = n.get_tokens(RobotToken.ARGUMENT)
 
-        for argument_token in (cast(RobotToken, e) for e in arguments):
+        arguments = node.get_tokens(Token.ARGUMENT)
+
+        for argument_token in arguments:
             try:
                 argument = self.get_variable_token(argument_token)
 
@@ -278,14 +269,8 @@ class BlockVariableVisitor(Visitor):
             except VariableError:
                 pass
 
-    def visit_ExceptHeader(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.errors import VariableError
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import ExceptHeader
-        from robot.variables import is_scalar_assign
-
-        n = cast(ExceptHeader, node)
-        variables = n.get_tokens(RobotToken.VARIABLE)[:1]
+    def visit_ExceptHeader(self, node: Statement) -> None:  # noqa: N802
+        variables = node.get_tokens(Token.VARIABLE)[:1]
         if variables and is_scalar_assign(variables[0].value):
             try:
                 variable = self.get_variable_token(variables[0])
@@ -304,23 +289,17 @@ class BlockVariableVisitor(Visitor):
             except VariableError:
                 pass
 
-    def visit_KeywordCall(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.errors import VariableError
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import KeywordCall
-
+    def visit_KeywordCall(self, node: KeywordCall) -> None:  # noqa: N802
         # TODO  analyze "Set Local/Global/Suite Variable"
 
-        n = cast(KeywordCall, node)
-
-        for assign_token in n.get_tokens(RobotToken.ASSIGN):
+        for assign_token in node.get_tokens(Token.ASSIGN):
             variable_token = self.get_variable_token(assign_token)
 
             try:
                 if variable_token is not None:
                     if (
                         self.position is not None
-                        and self.position in range_from_node(n)
+                        and self.position in range_from_node(node)
                         and self.position > range_from_token(variable_token).end
                     ):
                         continue
@@ -339,21 +318,15 @@ class BlockVariableVisitor(Visitor):
             except VariableError:
                 pass
 
-    def visit_InlineIfHeader(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.errors import VariableError
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import InlineIfHeader
-
-        n = cast(InlineIfHeader, node)
-
-        for assign_token in n.get_tokens(RobotToken.ASSIGN):
+    def visit_InlineIfHeader(self, node: Statement) -> None:  # noqa: N802
+        for assign_token in node.get_tokens(Token.ASSIGN):
             variable_token = self.get_variable_token(assign_token)
 
             try:
                 if variable_token is not None:
                     if (
                         self.position is not None
-                        and self.position in range_from_node(n)
+                        and self.position in range_from_node(node)
                         and self.position > range_from_token(variable_token).end
                     ):
                         continue
@@ -372,12 +345,8 @@ class BlockVariableVisitor(Visitor):
             except VariableError:
                 pass
 
-    def visit_ForHeader(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import ForHeader
-
-        n = cast(ForHeader, node)
-        variables = n.get_tokens(RobotToken.VARIABLE)
+    def visit_ForHeader(self, node: Statement) -> None:  # noqa: N802
+        variables = node.get_tokens(Token.VARIABLE)
         for variable in variables:
             variable_token = self.get_variable_token(variable)
             if variable_token is not None and variable_token.value and variable_token.value not in self._results:
@@ -391,6 +360,27 @@ class BlockVariableVisitor(Visitor):
                     source=self.source,
                 )
 
+    def visit_Var(self, node: Statement) -> None:  # noqa: N802
+        variable = node.get_token(Token.VARIABLE)
+        if variable is None:
+            return
+        try:
+            if not is_variable(variable.value):
+                return
+
+            self._results[variable.value] = LocalVariableDefinition(
+                name=variable.value,
+                name_token=strip_variable_token(variable),
+                line_no=variable.lineno,
+                col_offset=variable.col_offset,
+                end_line_no=variable.lineno,
+                end_col_offset=variable.end_col_offset,
+                source=self.source,
+            )
+
+        except VariableError:
+            pass
+
 
 class ImportVisitor(Visitor):
     def get(self, source: str, model: ast.AST) -> List[Import]:
@@ -400,31 +390,23 @@ class ImportVisitor(Visitor):
         return self._results
 
     def visit_Section(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.model.blocks import SettingSection
-
         if isinstance(node, SettingSection):
             self.generic_visit(node)
 
-    def visit_LibraryImport(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import LibraryImport as RobotLibraryImport
-
-        n = cast(RobotLibraryImport, node)
-        name = cast(RobotToken, n.get_token(RobotToken.NAME))
+    def visit_LibraryImport(self, node: RobotLibraryImport) -> None:  # noqa: N802
+        name = node.get_token(Token.NAME)
 
-        separator = n.get_token(RobotToken.WITH_NAME)
-        alias_token = n.get_tokens(RobotToken.NAME)[-1] if separator else None
+        separator = node.get_token(Token.WITH_NAME)
+        alias_token = node.get_tokens(Token.NAME)[-1] if separator else None
 
-        last_data_token = cast(
-            RobotToken, next(v for v in reversed(n.tokens) if v.type not in RobotToken.NON_DATA_TOKENS)
-        )
-        if n.name:
+        last_data_token = next(v for v in reversed(node.tokens) if v.type not in Token.NON_DATA_TOKENS)
+        if node.name:
             self._results.append(
                 LibraryImport(
-                    name=n.name,
+                    name=node.name,
                     name_token=name if name is not None else None,
-                    args=n.args,
-                    alias=n.alias,
+                    args=node.args,
+                    alias=node.alias,
                     alias_token=alias_token,
                     line_no=node.lineno,
                     col_offset=node.col_offset,
@@ -442,20 +424,14 @@ class ImportVisitor(Visitor):
                 )
             )
 
-    def visit_ResourceImport(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import ResourceImport as RobotResourceImport
+    def visit_ResourceImport(self, node: RobotResourceImport) -> None:  # noqa: N802
+        name = node.get_token(Token.NAME)
 
-        n = cast(RobotResourceImport, node)
-        name = cast(RobotToken, n.get_token(RobotToken.NAME))
-
-        last_data_token = cast(
-            RobotToken, next(v for v in reversed(n.tokens) if v.type not in RobotToken.NON_DATA_TOKENS)
-        )
-        if n.name:
+        last_data_token = next(v for v in reversed(node.tokens) if v.type not in Token.NON_DATA_TOKENS)
+        if node.name:
             self._results.append(
                 ResourceImport(
-                    name=n.name,
+                    name=node.name,
                     name_token=name if name is not None else None,
                     line_no=node.lineno,
                     col_offset=node.col_offset,
@@ -473,22 +449,16 @@ class ImportVisitor(Visitor):
                 )
             )
 
-    def visit_VariablesImport(self, node: ast.AST) -> None:  # noqa: N802
-        from robot.parsing.lexer.tokens import Token as RobotToken
-        from robot.parsing.model.statements import VariablesImport as RobotVariablesImport
+    def visit_VariablesImport(self, node: RobotVariablesImport) -> None:  # noqa: N802
+        name = node.get_token(Token.NAME)
 
-        n = cast(RobotVariablesImport, node)
-        name = cast(RobotToken, n.get_token(RobotToken.NAME))
-
-        last_data_token = cast(
-            RobotToken, next(v for v in reversed(n.tokens) if v.type not in RobotToken.NON_DATA_TOKENS)
-        )
-        if n.name:
+        last_data_token = next(v for v in reversed(node.tokens) if v.type not in Token.NON_DATA_TOKENS)
+        if node.name:
             self._results.append(
                 VariablesImport(
-                    name=n.name,
+                    name=node.name,
                     name_token=name if name is not None else None,
-                    args=n.args,
+                    args=node.args,
                     line_no=node.lineno,
                     col_offset=node.col_offset,
                     end_line_no=last_data_token.lineno
@@ -926,9 +896,6 @@ class Namespace:
         position: Optional[Position] = None,
         skip_commandline_variables: bool = False,
     ) -> AsyncIterator[Tuple[VariableMatcher, VariableDefinition]]:
-        from robot.parsing.model.blocks import Keyword, TestCase
-        from robot.parsing.model.statements import Arguments
-
         yielded: Dict[VariableMatcher, VariableDefinition] = {}
 
         test_or_keyword_nodes = list(
@@ -2020,8 +1987,6 @@ class KeywordFinder:
     def _filter_stdlib_runner(
         self, entry1: Tuple[Optional[LibraryEntry], KeywordDoc], entry2: Tuple[Optional[LibraryEntry], KeywordDoc]
     ) -> List[Tuple[Optional[LibraryEntry], KeywordDoc]]:
-        from robot.libraries import STDLIBS
-
         stdlibs_without_remote = STDLIBS - {"Remote"}
         if entry1[0] is not None and entry1[0].name in stdlibs_without_remote:
             standard, custom = entry1, entry2

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/src/robotcode/language_server/robotframework/parts/code_action_quick_fixes.py

@@ -34,6 +34,7 @@ from ..utils.ast_utils import (
     get_node_at_position,
     get_nodes_at_position,
     get_tokens_at_position,
+    iter_nodes,
     range_from_node,
     range_from_token,
 )
@@ -655,7 +656,7 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
     ) -> Optional[CodeAction]:
         from robot.parsing.lexer.tokens import Token
         from robot.parsing.model.blocks import Keyword
-        from robot.parsing.model.statements import Arguments, Documentation
+        from robot.parsing.model.statements import Arguments, Documentation, KeywordName, Statement
 
         if data.range.start.line == data.range.end.line and data.range.start.character <= data.range.end.character:
             document = await self.parent.documents.get(data.document_uri)
@@ -676,14 +677,16 @@ class RobotCodeActionQuickFixesProtocolPart(RobotLanguageServerProtocolPart, Mod
             arguments = next((n for n in keyword.body if isinstance(n, Arguments)), None)
 
             if arguments is None:
-                i = 0
-                first_stmt = keyword.body[i]
-
-                while isinstance(first_stmt, Documentation) and i < len(keyword.body):
-                    i += 1
-                    first_stmt = keyword.body[i]
+                first_stmt = next(
+                    (
+                        n
+                        for n in iter_nodes(keyword)
+                        if isinstance(n, Statement) and not isinstance(n, (KeywordName, Documentation))
+                    ),
+                    None,
+                )
 
-                if i >= len(keyword.body):
+                if first_stmt is None:
                     return None
 
                 spaces = (

{robotcode_language_server-0.64.0 → robotcode_language_server-0.65.1}/src/robotcode/language_server/robotframework/parts/hover.py

@@ -17,6 +17,7 @@ from typing import (
 
 from robotcode.core.logging import LoggingDescriptor
 from robotcode.core.lsp.types import Hover, MarkupContent, MarkupKind, Position, Range
+from robotcode.robot.utils.markdownformatter import MarkDownFormatter
 
 from ...common.decorators import language_id
 from ...common.text_document import TextDocument
@@ -26,7 +27,6 @@ from ..utils.ast_utils import (
     range_from_node,
     range_from_token,
 )
-from ..utils.markdownformatter import MarkDownFormatter
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:

robotcode_language_server-0.64.0/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.64.0"

robotcode_language_server-0.64.0/src/robotcode/language_server/robotframework/utils/markdownformatter.py

@@ -1,358 +0,0 @@
-from __future__ import annotations
-
-import functools
-import itertools
-import re
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Iterator, List, Optional, Tuple
-
-
-class Formatter(ABC):
-    _strip_lines = True
-
-    def __init__(self) -> None:
-        self._lines: List[str] = []
-
-    def handles(self, line: str) -> bool:
-        return self._handles(line.strip() if self._strip_lines else line)
-
-    @abstractmethod
-    def _handles(self, line: str) -> bool:
-        ...
-
-    def add(self, line: str) -> None:
-        self._lines.append(line.strip() if self._strip_lines else line)
-
-    def end(self) -> str:
-        result = self.format(self._lines)
-        self._lines = []
-        return result
-
-    @abstractmethod
-    def format(self, lines: List[str]) -> str:
-        ...
-
-
-class MarkDownFormatter:
-    def __init__(self) -> None:
-        self._results: List[str] = []
-        self._formatters: List[Formatter] = [
-            TableFormatter(),
-            PreformattedFormatter(),
-            ListFormatter(),
-            HeaderFormatter(),
-            RulerFormatter(),
-        ]
-        self._formatters.append(ParagraphFormatter(self._formatters[:]))
-        self._current: Optional[Formatter] = None
-
-    def format(self, text: str) -> str:
-        for line in text.splitlines():
-            self._process_line(line)
-        self._end_current()
-        return "\n".join(self._results)
-
-    def _process_line(self, line: str) -> None:
-        if not line.strip():
-            self._end_current()
-        elif self._current and self._current.handles(line):
-            self._current.add(line)
-        else:
-            self._end_current()
-            self._current = self._find_formatter(line)
-            if self._current is not None:
-                self._current.add(line)
-
-    def _end_current(self) -> None:
-        if self._current:
-            self._results.append(self._current.end())
-            self._current = None
-
-    def _find_formatter(self, line: str) -> Optional[Formatter]:
-        for formatter in self._formatters:
-            if formatter.handles(line):
-                return formatter
-        return None
-
-
-class SingleLineFormatter(Formatter):
-    def _handles(self, line: str) -> bool:
-        return bool(not self._lines and self.match(line))
-
-    @abstractmethod
-    def match(self, line: str) -> Optional[re.Match[str]]:
-        ...
-
-    def format(self, lines: List[str]) -> str:
-        return self.format_line(lines[0])
-
-    @abstractmethod
-    def format_line(self, line: str) -> str:
-        ...
-
-
-class HeaderFormatter(SingleLineFormatter):
-    _regex = re.compile(r"^(={1,5})\s+(\S.*?)\s+\1$")
-
-    def match(self, line: str) -> Optional[re.Match[str]]:
-        return self._regex.match(line)
-
-    def format_line(self, line: str) -> str:
-        m = self.match(line)
-        if m is not None:
-            level, text = m.groups()
-
-            return "%s %s\n" % ("#" * (len(level) + 1), text)
-        return ""
-
-
-class LinkFormatter:
-    _image_exts = (".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg")
-    _link = re.compile(r"\[(.+?\|.*?)\]")
-    _url = re.compile(
-        r"""
-((^|\ ) ["'(\[{]*)           # begin of line or space and opt. any char "'([{
-([a-z][\w+-.]*://[^\s|]+?)   # url
-(?=[)\]}"'.,!?:;|]* ($|\ ))  # opt. any char )]}"'.,!?:;| and eol or space
-""",
-        re.VERBOSE | re.MULTILINE | re.IGNORECASE,
-    )
-
-    def format_url(self, text: str) -> str:
-        return self._format_url(text, format_as_image=False)
-
-    def _format_url(self, text: str, format_as_image: bool = True) -> str:
-        if "://" not in text:
-            return text
-        return self._url.sub(functools.partial(self._replace_url, format_as_image), text)
-
-    def _replace_url(self, format_as_image: bool, match: re.Match[str]) -> str:
-        pre = match.group(1)
-        url = match.group(3)
-        if format_as_image and self._is_image(url):
-            return pre + self._get_image(url)
-        return pre + self._get_link(url)
-
-    def _get_image(self, src: str, title: Optional[str] = None) -> str:
-        return f"![{title or src}]({src})"
-
-    def _get_link(self, href: str, content: Optional[str] = None) -> str:
-        return f"[{content or href}]({href})"
-
-    def _quot(self, attr: str) -> str:
-        return attr if '"' not in attr else attr.replace('"', """)
-
-    def format_link(self, text: str) -> str:
-        # 2nd, 4th, etc. token contains link, others surrounding content
-        tokens = self._link.split(text)
-
-        formatters: Iterator[Callable[[str], Any]] = itertools.cycle((self._format_url, self._format_link))
-        return "".join(f(t) for f, t in zip(formatters, tokens))
-
-    def _format_link(self, text: str) -> str:
-        link, content = [t.strip() for t in text.split("|", 1)]
-        if self._is_image(content):
-            content = self._get_image(content, link)
-        elif self._is_image(link):
-            return self._get_image(link, content)
-        if link.startswith("\\#"):
-            link = link.lower()
-        return self._get_link(link, content)
-
-    def remove_link(self, text: str) -> str:
-        # 2nd, 4th, etc. token contains link, others surrounding content
-        tokens = self._link.split(text)
-        if len(tokens) > 1:
-            formatters: Iterator[Callable[[str], Any]] = itertools.cycle([self._remove_link])
-            return "".join(f(t) for f, t in zip(formatters, tokens))
-        return text
-
-    def _remove_link(self, text: str) -> str:
-        if "|" not in text:
-            return text
-
-        link, content = [t.strip() for t in text.split("|", 1)]
-        if self._is_image(content):
-            return self._get_image(content, link)
-
-        return content
-
-    def _is_image(self, text: str) -> bool:
-        return text.startswith("data:image/") or text.lower().endswith(self._image_exts)
-
-
-class LineFormatter:
-    _bold = re.compile(
-        r"""
-(                         # prefix (group 1)
-  (^|\ )                  # begin of line or space
-  ["'(]* _?               # optionally any char "'( and optional begin of italic
-)                         #
-\*                        # start of bold
-([^\ ].*?)                # no space and then anything (group 3)
-\*                        # end of bold
-(?=                       # start of postfix (non-capturing group)
-  _? ["').,!?:;]*         # optional end of italic and any char "').,!?:;
-  ($|\ )                  # end of line or space
-)
-""",
-        re.VERBOSE,
-    )
-    _italic = re.compile(
-        r"""
-( (^|\ ) ["'(]* )          # begin of line or space and opt. any char "'(
-_                          # start of italic
-([^\ _].*?)                # no space or underline and then anything
-_                          # end of italic
-(?= ["').,!?:;]* ($|\ ) )  # opt. any char "').,!?:; and end of line or space
-""",
-        re.VERBOSE,
-    )
-    _code = re.compile(
-        r"""
-( (^|\ ) ["'(]* )          # same as above with _ changed to ``
-``
-([^\ `].*?)
-``
-(?= ["').,!?:;]* ($|\ ) )
-""",
-        re.VERBOSE,
-    )
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        self._formatters: List[Tuple[str, Callable[[str], str]]] = [
-            ("<", self._quote_lower_then),
-            ("#", self._quote_hash),
-            ("*", self._format_bold),
-            ("_", self._format_italic),
-            ("``", self._format_code),
-            ("", functools.partial(LinkFormatter().format_link)),
-        ]
-
-    def format(self, line: str) -> str:
-        for marker, formatter in self._formatters:
-            if marker in line:
-                line = formatter(line)
-        return line
-
-    def _quote_lower_then(self, line: str) -> str:
-        return line.replace("<", "\\<")
-
-    def _quote_hash(self, line: str) -> str:
-        return line.replace("#", "\\#")
-
-    def _format_bold(self, line: str) -> str:
-        return self._bold.sub("\\1**\\3**", line)
-
-    def _format_italic(self, line: str) -> str:
-        return self._italic.sub("\\1*\\3*", line)
-
-    def _format_code(self, line: str) -> str:
-        return self._code.sub("\\1`\\3`", line)
-
-
-class PreformattedFormatter(Formatter):
-    _format_line = functools.partial(LineFormatter().format)
-
-    def _handles(self, line: str) -> bool:
-        return line.startswith("| ") or line == "|"
-
-    def format(self, lines: List[str]) -> str:
-        lines = [LinkFormatter().remove_link(line[2:]) for line in lines]
-        return "```text\n" + "\n".join(lines) + "\n```\n"
-
-
-class ParagraphFormatter(Formatter):
-    _format_line = functools.partial(LineFormatter().format)
-
-    def __init__(self, other_formatters: List[Formatter]) -> None:
-        super().__init__()
-        self._other_formatters = other_formatters
-
-    def _handles(self, line: str) -> bool:
-        return not any(other.handles(line) for other in self._other_formatters)
-
-    def format(self, lines: List[str]) -> str:
-        return self._format_line(" ".join(lines)) + "\n\n"
-
-
-class ListFormatter(Formatter):
-    _strip_lines = False
-    _format_item = functools.partial(LineFormatter().format)
-
-    def _handles(self, line: str) -> bool:
-        return bool(line.strip().startswith("- ") or line.startswith(" ") and self._lines)
-
-    def format(self, lines: List[str]) -> str:
-        items = ["- %s" % self._format_item(line) for line in self._combine_lines(lines)]
-        return "\n".join(items) + "\n\n"
-
-    def _combine_lines(self, lines: List[str]) -> Iterator[str]:
-        current = []
-        for line in lines:
-            line = line.strip()
-            if not line.startswith("- "):
-                current.append(line)
-                continue
-            if current:
-                yield " ".join(current)
-            current = [line[2:].strip()]
-        yield " ".join(current)
-
-
-class RulerFormatter(SingleLineFormatter):
-    regex = re.compile("^-{3,}$")
-
-    def match(self, line: str) -> Optional[re.Match[str]]:
-        return self.regex.match(line)
-
-    def format_line(self, line: str) -> str:
-        return "---"
-
-
-class TableFormatter(Formatter):
-    _table_line = re.compile(r"^\| (.* |)\|$")
-    _line_splitter = re.compile(r" \|(?= )")
-    _format_cell_content = functools.partial(LineFormatter().format)
-
-    def _handles(self, line: str) -> bool:
-        return self._table_line.match(line) is not None
-
-    def format(self, lines: List[str]) -> str:
-        return self._format_table([self._split_to_cells(line) for line in lines])
-
-    def _split_to_cells(self, line: str) -> List[str]:
-        return [cell.strip() for cell in self._line_splitter.split(line[1:-1])]
-
-    def _format_table(self, rows: List[List[str]]) -> str:
-        table = []
-
-        max_columns = max(len(row) for row in rows)
-
-        try:
-            header_rows = [list(next(row for row in rows if any(cell for cell in row if cell.startswith("="))))]
-        except StopIteration:
-            header_rows = [[]]
-
-        body_rows = [row for row in rows if row not in header_rows]
-
-        for row in header_rows or [[]]:
-            row += [""] * (max_columns - len(row))
-            table.append(f'|{"|".join(self._format_cell(cell) for cell in row)}|')
-
-        row_ = [" :--- "] * max_columns
-        table.append(f'|{"|".join(row_)}|')
-
-        for row in body_rows:
-            row += [""] * (max_columns - len(row))
-            table.append(f'|{"|".join(self._format_cell(cell) for cell in row)}|')
-
-        return "\n".join(table) + "\n\n"
-
-    def _format_cell(self, content: str) -> str:
-        if content.startswith("=") and content.endswith("="):
-            content = content[1:-1]
-
-        return f" {self._format_cell_content(content).strip()} "